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

package/lib/containerRuntime.js

@@ -1,9 +1,11 @@
 import { AttachState, LoaderHeader, } from "@fluidframework/container-definitions";
-import { assert, delay, LazyPromise, Trace, TypedEventEmitter, unreachableCase, } from "@fluidframework/common-utils";
-import { ChildLogger, raiseConnectedEvent, PerformanceEvent, TaggedLoggerAdapter, loggerToMonitoringContext, wrapError, } from "@fluidframework/telemetry-utils";
+import { assert, delay, LazyPromise } from "@fluidframework/core-utils";
+import { Trace, TypedEventEmitter } from "@fluid-internal/client-utils";
+import { createChildLogger, createChildMonitoringContext, DataCorruptionError, DataProcessingError, GenericError, raiseConnectedEvent, PerformanceEvent, 
+// eslint-disable-next-line import/no-deprecated
+TaggedLoggerAdapter, wrapError, UsageError, } from "@fluidframework/telemetry-utils";
 import { DriverHeader, FetchSource, } from "@fluidframework/driver-definitions";
 import { readAndParse } from "@fluidframework/driver-utils";
-import { DataCorruptionError, DataProcessingError, GenericError, UsageError, } from "@fluidframework/container-utils";
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { FlushMode, FlushModeExperimental, gcTreeKey, channelsTreeName, } from "@fluidframework/runtime-definitions";
 import { addBlobToSummary, addSummarizeResultToSummary, addTreeToSummary, RequestParser, create404Response, exceptionToResponse, GCDataBuilder, requestFluidObject, seqFromTree, calculateStats, TelemetryContext, } from "@fluidframework/runtime-utils";
@@ -11,17 +13,17 @@ import { v4 as uuid } from "uuid";
 import { ContainerFluidHandleContext } from "./containerHandleContext";
 import { FluidDataStoreRegistry } from "./dataStoreRegistry";
 import { ReportOpPerfTelemetry } from "./connectionTelemetry";
-import { PendingStateManager } from "./pendingStateManager";
+import { PendingStateManager, } from "./pendingStateManager";
 import { pkgVersion } from "./packageVersion";
 import { BlobManager } from "./blobManager";
 import { DataStores, getSummaryForDatastores } from "./dataStores";
-import { aliasBlobName, blobsTreeName, chunksBlobName, createRootSummarizerNodeWithGC, electedSummarizerBlobName, extractSummaryMetadataMessage, idCompressorBlobName, metadataBlobName, Summarizer, SummaryManager, wrapSummaryInChannelsTree, SummaryCollection, OrderedClientCollection, OrderedClientElection, SummarizerClientElection, summarizerClientType, RunWhileConnectedCoordinator, } from "./summary";
+import { aliasBlobName, blobsTreeName, chunksBlobName, createRootSummarizerNodeWithGC, electedSummarizerBlobName, extractSummaryMetadataMessage, idCompressorBlobName, metadataBlobName, Summarizer, SummaryManager, wrapSummaryInChannelsTree, SummaryCollection, OrderedClientCollection, OrderedClientElection, SummarizerClientElection, summarizerClientType, RunWhileConnectedCoordinator, RetriableSummaryError, } from "./summary";
 import { formExponentialFn, Throttler } from "./throttler";
 import { GarbageCollector, GCNodeType, gcTombstoneGenerationOptionName, shouldAllowGcTombstoneEnforcement, trimLeadingAndTrailingSlashes, } from "./gc";
 import { channelToDataStore, isDataStoreAliasMessage } from "./dataStore";
 import { BindBatchTracker } from "./batchTracker";
 import { ScheduleManager } from "./scheduleManager";
-import { OpCompressor, OpDecompressor, Outbox, OpSplitter, RemoteMessageProcessor, OpGroupingManager, } from "./opLifecycle";
+import { OpCompressor, OpDecompressor, Outbox, OpSplitter, RemoteMessageProcessor, OpGroupingManager, getLongStack, } from "./opLifecycle";
 import { DeltaManagerSummarizerProxy } from "./deltaManagerSummarizerProxy";
 export var ContainerMessageType;
 (function (ContainerMessageType) {
@@ -44,6 +46,18 @@ export var ContainerMessageType;
      */
     ContainerMessageType["IdAllocation"] = "idAllocation";
 })(ContainerMessageType || (ContainerMessageType = {}));
+/**
+ * Utility to implement compat behaviors given an unknown message type
+ * The parameters are typed to support compile-time enforcement of handling all known types/behaviors
+ *
+ * @param _unknownContainerRuntimeMessageType - Typed as never, to ensure all known types have been
+ * handled before calling this function (e.g. in a switch statement).
+ * @param compatBehavior - Typed redundantly with CompatModeBehavior to ensure handling is added when updating that type
+ */
+function compatBehaviorAllowsMessageType(_unknownContainerRuntimeMessageType, compatBehavior) {
+    // undefined defaults to same behavior as "FailToProcess"
+    return compatBehavior === "Ignore";
+}
 export const DefaultSummaryConfiguration = {
     state: "enabled",
     minIdleTime: 0,
@@ -70,8 +84,12 @@ export var RuntimeHeaders;
 })(RuntimeHeaders || (RuntimeHeaders = {}));
 /** True if a tombstoned object should be returned without erroring */
 export const AllowTombstoneRequestHeaderKey = "allowTombstone"; // Belongs in the enum above, but avoiding the breaking change
+/** [IRRELEVANT IF throwOnInactiveLoad OPTION NOT SET] True if an inactive object should be returned without erroring */
+export const AllowInactiveRequestHeaderKey = "allowInactive"; // Belongs in the enum above, but avoiding the breaking change
 /** Tombstone error responses will have this header set to true */
 export const TombstoneResponseHeaderKey = "isTombstoned";
+/** Inactive error responses will have this header set to true */
+export const InactiveResponseHeaderKey = "isInactive";
 /** Default values for Runtime Headers */
 export const defaultRuntimeHeaderData = {
     wait: true,
@@ -98,12 +116,16 @@ const defaultCompressionConfig = {
     compressionAlgorithm: CompressionAlgorithms.lz4,
 };
 const defaultChunkSizeInBytes = 204800;
+/** The default time to wait for pending ops to be processed during summarization */
+export const defaultPendingOpsWaitTimeoutMs = 1000;
+/** The default time to delay a summarization retry attempt when there are pending ops */
+export const defaultPendingOpsRetryDelayMs = 1000;
 /**
  * Instead of refreshing from latest because we do not have 100% confidence in the state
  * of the current system, we should close the summarizer and let it recover.
  * This delay's goal is to prevent tight restart loops
  */
-const defaultCloseSummarizerDelayMs = 10000; // 10 seconds
+const defaultCloseSummarizerDelayMs = 5000; // 5 seconds
 /**
  * @deprecated - use ContainerRuntimeMessage instead
  */
@@ -139,9 +161,23 @@ export function getDeviceSpec() {
             };
         }
     }
-    catch (_a) { }
+    catch { }
     return {};
 }
+/**
+ * Older loader doesn't have a submitBatchFn member, this is the older way of submitting a batch.
+ * Rather than exposing the submitFn (now deprecated) and IDeltaManager (dangerous to hand out) to the Outbox,
+ * we can provide a partially-applied function to keep those items private to the ContainerRuntime.
+ */
+export const makeLegacySendBatchFn = (submitFn, deltaManager) => (batch) => {
+    for (const message of batch.content) {
+        submitFn(MessageType.Operation, 
+        // For back-compat (submitFn only works on deserialized content)
+        message.contents === undefined ? undefined : JSON.parse(message.contents), true, // batch
+        message.metadata);
+    }
+    deltaManager.flush();
+};
 /**
  * Represents the runtime of the container. Contains helper functions/state of the container.
  * It will define the store level mappings.
@@ -150,11 +186,13 @@ export class ContainerRuntime extends TypedEventEmitter {
     /**
      * @internal
      */
-    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, idCompressor, requestHandler, summaryConfiguration, initializeEntryPoint) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        if (summaryConfiguration === void 0) { summaryConfiguration = Object.assign(Object.assign({}, DefaultSummaryConfiguration), (_a = runtimeOptions.summaryOptions) === null || _a === void 0 ? void 0 : _a.summaryConfigOverrides); }
+    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, idCompressor, requestHandler, summaryConfiguration = {
+        // the defaults
+        ...DefaultSummaryConfiguration,
+        // the runtime configuration overrides
+        ...runtimeOptions.summaryOptions?.summaryConfigOverrides,
+    }, initializeEntryPoint) {
         super();
-        this.context = context;
         this.registry = registry;
         this.runtimeOptions = runtimeOptions;
         this.containerScope = containerScope;
@@ -183,51 +221,56 @@ export class ContainerRuntime extends TypedEventEmitter {
             signalTimestamp: 0,
             trackingSignalSequenceNumber: undefined,
         };
-        this.summarizeOnDemand = (...args) => {
-            if (this.clientDetails.type === summarizerClientType) {
-                return this.summarizer.summarizeOnDemand(...args);
-            }
-            else if (this.summaryManager !== undefined) {
-                return this.summaryManager.summarizeOnDemand(...args);
-            }
-            else {
-                // If we're not the summarizer, and we don't have a summaryManager, we expect that
-                // disableSummaries is turned on. We are throwing instead of returning a failure here,
-                // because it is a misuse of the API rather than an expected failure.
-                throw new UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
-            }
-        };
-        this.enqueueSummarize = (...args) => {
-            if (this.clientDetails.type === summarizerClientType) {
-                return this.summarizer.enqueueSummarize(...args);
-            }
-            else if (this.summaryManager !== undefined) {
-                return this.summaryManager.enqueueSummarize(...args);
+        const { options, clientDetails, connected, baseSnapshot, submitFn, submitBatchFn, submitSummaryFn, submitSignalFn, disposeFn, closeFn, deltaManager, quorum, audience, loader, pendingLocalState, supportedFeatures, } = context;
+        this.innerDeltaManager = deltaManager;
+        this.deltaManager = new DeltaManagerSummarizerProxy(this.innerDeltaManager);
+        // Here we could wrap/intercept on these functions to block/modify outgoing messages if needed.
+        // This makes ContainerRuntime the final gatekeeper for outgoing messages.
+        this.submitFn = submitFn;
+        this.submitBatchFn = submitBatchFn;
+        this.submitSummaryFn = submitSummaryFn;
+        this.submitSignalFn = submitSignalFn;
+        this.options = options;
+        this.clientDetails = clientDetails;
+        this.isSummarizerClient = this.clientDetails.type === summarizerClientType;
+        this.loadedFromVersionId = context.getLoadedFromVersion()?.id;
+        this._getClientId = () => context.clientId;
+        this._getAttachState = () => context.attachState;
+        this.getAbsoluteUrl = async (relativeUrl) => {
+            if (context.getAbsoluteUrl === undefined) {
+                throw new Error("Driver does not implement getAbsoluteUrl");
             }
-            else {
-                // If we're not the summarizer, and we don't have a summaryManager, we expect that
-                // generateSummaries is turned off. We are throwing instead of returning a failure here,
-                // because it is a misuse of the API rather than an expected failure.
-                throw new UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
+            if (this.attachState !== AttachState.Attached) {
+                return undefined;
             }
+            return context.getAbsoluteUrl(relativeUrl);
         };
-        this.innerDeltaManager = context.deltaManager;
-        this.deltaManager = new DeltaManagerSummarizerProxy(context.deltaManager);
-        this.mc = loggerToMonitoringContext(ChildLogger.create(this.logger, "ContainerRuntime"));
+        // TODO: Consider that the Container could just listen to these events itself, or even more appropriately maybe the
+        // customer should observe dirty state on the runtime (the owner of dirty state) directly, rather than on the IContainer.
+        this.on("dirty", () => context.updateDirtyContainerState(true));
+        this.on("saved", () => context.updateDirtyContainerState(false));
+        // In old loaders without dispose functionality, closeFn is equivalent but will also switch container to readonly mode
+        this.disposeFn = disposeFn ?? closeFn;
+        // In cases of summarizer, we want to dispose instead since consumer doesn't interact with this container
+        this.closeFn = this.isSummarizerClient ? this.disposeFn : closeFn;
+        this.mc = createChildMonitoringContext({
+            logger: this.logger,
+            namespace: "ContainerRuntime",
+        });
         let loadSummaryNumber;
         // Get the container creation metadata. For new container, we initialize these. For existing containers,
         // get the values from the metadata blob.
         if (existing) {
             this.createContainerMetadata = {
-                createContainerRuntimeVersion: metadata === null || metadata === void 0 ? void 0 : metadata.createContainerRuntimeVersion,
-                createContainerTimestamp: metadata === null || metadata === void 0 ? void 0 : metadata.createContainerTimestamp,
+                createContainerRuntimeVersion: metadata?.createContainerRuntimeVersion,
+                createContainerTimestamp: metadata?.createContainerTimestamp,
             };
             // summaryNumber was renamed from summaryCount. For older docs that haven't been opened for a long time,
             // the count is reset to 0.
-            loadSummaryNumber = (_b = metadata === null || metadata === void 0 ? void 0 : metadata.summaryNumber) !== null && _b !== void 0 ? _b : 0;
+            loadSummaryNumber = metadata?.summaryNumber ?? 0;
             // Enabling the IdCompressor is a one-way operation and we only want to
             // allow new containers to turn it on
-            this.idCompressorEnabled = (_c = metadata === null || metadata === void 0 ? void 0 : metadata.idCompressorEnabled) !== null && _c !== void 0 ? _c : false;
+            this.idCompressorEnabled = metadata?.idCompressorEnabled ?? false;
         }
         else {
             this.createContainerMetadata = {
@@ -236,24 +279,27 @@ export class ContainerRuntime extends TypedEventEmitter {
             };
             loadSummaryNumber = 0;
             this.idCompressorEnabled =
-                (_d = this.mc.config.getBoolean("Fluid.ContainerRuntime.IdCompressorEnabled")) !== null && _d !== void 0 ? _d : idCompressor !== undefined;
+                this.mc.config.getBoolean("Fluid.ContainerRuntime.IdCompressorEnabled") ??
+                    idCompressor !== undefined;
         }
         this.nextSummaryNumber = loadSummaryNumber + 1;
-        this.messageAtLastSummary = metadata === null || metadata === void 0 ? void 0 : metadata.message;
-        this._connected = this.context.connected;
-        this.gcTombstoneEnforcementAllowed = shouldAllowGcTombstoneEnforcement((_e = metadata === null || metadata === void 0 ? void 0 : metadata.gcFeatureMatrix) === null || _e === void 0 ? void 0 : _e.tombstoneGeneration /* persisted */, this.runtimeOptions.gcOptions[gcTombstoneGenerationOptionName] /* current */);
+        this.messageAtLastSummary = metadata?.message;
+        // Note that we only need to pull the *initial* connected state from the context.
+        // Later updates come through calls to setConnectionState.
+        this._connected = connected;
+        this.gcTombstoneEnforcementAllowed = shouldAllowGcTombstoneEnforcement(metadata?.gcFeatureMatrix?.tombstoneGeneration /* persisted */, this.runtimeOptions.gcOptions[gcTombstoneGenerationOptionName] /* current */);
         this.mc.logger.sendTelemetryEvent({
             eventName: "GCFeatureMatrix",
-            metadataValue: JSON.stringify(metadata === null || metadata === void 0 ? void 0 : metadata.gcFeatureMatrix),
+            metadataValue: JSON.stringify(metadata?.gcFeatureMatrix),
             inputs: JSON.stringify({
                 gcOptions_gcTombstoneGeneration: this.runtimeOptions.gcOptions[gcTombstoneGenerationOptionName],
             }),
         });
-        this.telemetryDocumentId = (_f = metadata === null || metadata === void 0 ? void 0 : metadata.telemetryDocumentId) !== null && _f !== void 0 ? _f : uuid();
+        this.telemetryDocumentId = metadata?.telemetryDocumentId ?? uuid();
         this.disableAttachReorder = this.mc.config.getBoolean("Fluid.ContainerRuntime.disableAttachOpReorder");
         const disableChunking = this.mc.config.getBoolean("Fluid.ContainerRuntime.CompressionChunkingDisabled");
         const opGroupingManager = new OpGroupingManager(this.groupedBatchingEnabled);
-        const opSplitter = new OpSplitter(chunks, this.context.submitBatchFn, disableChunking === true ? Number.POSITIVE_INFINITY : runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger);
+        const opSplitter = new OpSplitter(chunks, this.submitBatchFn, disableChunking === true ? Number.POSITIVE_INFINITY : runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger);
         this.remoteMessageProcessor = new RemoteMessageProcessor(opSplitter, new OpDecompressor(this.mc.logger), opGroupingManager);
         this.handleContext = new ContainerFluidHandleContext("", this);
         if (this.summaryConfiguration.state === "enabled") {
@@ -272,9 +318,10 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.idCompressor = idCompressor;
         }
         this.maxConsecutiveReconnects =
-            (_g = this.mc.config.getNumber(maxConsecutiveReconnectsKey)) !== null && _g !== void 0 ? _g : this.defaultMaxConsecutiveReconnects;
+            this.mc.config.getNumber(maxConsecutiveReconnectsKey) ??
+                this.defaultMaxConsecutiveReconnects;
         if (runtimeOptions.flushMode === FlushModeExperimental.Async &&
-            ((_h = context.supportedFeatures) === null || _h === void 0 ? void 0 : _h.get("referenceSequenceNumbers")) !== true) {
+            supportedFeatures?.get("referenceSequenceNumbers") !== true) {
             // The loader does not support reference sequence numbers, falling back on FlushMode.TurnBased
             this.mc.logger.sendErrorEvent({ eventName: "FlushModeFallback" });
             this._flushMode = FlushMode.TurnBased;
@@ -282,8 +329,8 @@ export class ContainerRuntime extends TypedEventEmitter {
         else {
             this._flushMode = runtimeOptions.flushMode;
         }
-        const pendingRuntimeState = context.pendingLocalState;
-        const maxSnapshotCacheDurationMs = (_k = (_j = this._storage) === null || _j === void 0 ? void 0 : _j.policies) === null || _k === void 0 ? void 0 : _k.maximumCacheDurationMs;
+        const pendingRuntimeState = pendingLocalState;
+        const maxSnapshotCacheDurationMs = this._storage?.policies?.maximumCacheDurationMs;
         if (maxSnapshotCacheDurationMs !== undefined &&
             maxSnapshotCacheDurationMs > 5 * 24 * 60 * 60 * 1000) {
             // This is a runtime enforcement of what's already explicit in the policy's type itself,
@@ -294,28 +341,27 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.garbageCollector = GarbageCollector.create({
             runtime: this,
             gcOptions: this.runtimeOptions.gcOptions,
-            baseSnapshot: context.baseSnapshot,
+            baseSnapshot,
             baseLogger: this.mc.logger,
             existing,
             metadata,
             createContainerMetadata: this.createContainerMetadata,
-            isSummarizerClient: this.context.clientDetails.type === summarizerClientType,
+            isSummarizerClient: this.isSummarizerClient,
             getNodePackagePath: async (nodePath) => this.getGCNodePackagePath(nodePath),
-            getLastSummaryTimestampMs: () => { var _a; return (_a = this.messageAtLastSummary) === null || _a === void 0 ? void 0 : _a.timestamp; },
+            getLastSummaryTimestampMs: () => this.messageAtLastSummary?.timestamp,
             readAndParseBlob: async (id) => readAndParse(this.storage, id),
-            getContainerDiagnosticId: () => this.context.id,
             // GC runs in summarizer client and needs access to the real (non-proxy) active information. The proxy
             // delta manager would always return false for summarizer client.
             activeConnection: () => this.innerDeltaManager.active,
         });
         const loadedFromSequenceNumber = this.deltaManager.initialSequenceNumber;
-        this.summarizerNode = createRootSummarizerNodeWithGC(ChildLogger.create(this.logger, "SummarizerNode"), 
+        this.summarizerNode = createRootSummarizerNodeWithGC(createChildLogger({ logger: this.logger, namespace: "SummarizerNode" }), 
         // Summarize function to call when summarize is called. Summarizer node always tracks summary state.
         async (fullTree, trackState, telemetryContext) => this.summarizeInternal(fullTree, trackState, telemetryContext), 
         // Latest change sequence number, no changes since summary applied yet
         loadedFromSequenceNumber, 
         // Summary reference sequence number, undefined if no summary yet
-        context.baseSnapshot ? loadedFromSequenceNumber : undefined, {
+        baseSnapshot !== undefined ? loadedFromSequenceNumber : undefined, {
             // Must set to false to prevent sending summary handle which would be pointing to
             // a summary with an older protocol state.
             canReuseHandle: false,
@@ -329,27 +375,28 @@ export class ContainerRuntime extends TypedEventEmitter {
         async (fullGC) => this.getGCDataInternal(fullGC), 
         // Function to get the GC details from the base snapshot we loaded from.
         async () => this.garbageCollector.getBaseGCDetails());
-        if (context.baseSnapshot) {
-            this.summarizerNode.updateBaseSummaryState(context.baseSnapshot);
+        if (baseSnapshot) {
+            this.summarizerNode.updateBaseSummaryState(baseSnapshot);
         }
-        this.dataStores = new DataStores(getSummaryForDatastores(context.baseSnapshot, metadata), this, (attachMsg) => this.submit(ContainerMessageType.Attach, attachMsg), (id, createParam) => (summarizeInternal, getGCDataFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), (path) => this.garbageCollector.isNodeDeleted(path), new Map(dataStoreAliasMap));
+        this.dataStores = new DataStores(getSummaryForDatastores(baseSnapshot, metadata), this, (attachMsg) => this.submit({ type: ContainerMessageType.Attach, contents: attachMsg }), (id, createParam) => (summarizeInternal, getGCDataFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), (path) => this.garbageCollector.isNodeDeleted(path), new Map(dataStoreAliasMap));
         this.blobManager = new BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (localId, blobId) => {
             if (!this.disposed) {
-                this.submit(ContainerMessageType.BlobAttach, undefined, undefined, {
+                this.submit({ type: ContainerMessageType.BlobAttach, contents: undefined }, undefined, {
                     localId,
                     blobId,
                 });
             }
-        }, (blobPath) => this.garbageCollector.nodeUpdated(blobPath, "Loaded"), (blobPath) => this.garbageCollector.isNodeDeleted(blobPath), this, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pendingAttachmentBlobs, (error) => this.closeFn(error));
-        this.scheduleManager = new ScheduleManager(context.deltaManager, this, () => this.clientId, ChildLogger.create(this.logger, "ScheduleManager"));
+        }, (blobPath) => this.garbageCollector.nodeUpdated(blobPath, "Loaded"), (blobPath) => this.garbageCollector.isNodeDeleted(blobPath), this, pendingRuntimeState?.pendingAttachmentBlobs, (error) => this.closeFn(error));
+        this.scheduleManager = new ScheduleManager(this.innerDeltaManager, this, () => this.clientId, createChildLogger({ logger: this.logger, namespace: "ScheduleManager" }));
         this.pendingStateManager = new PendingStateManager({
             applyStashedOp: this.applyStashedOp.bind(this),
             clientId: () => this.clientId,
             close: this.closeFn,
             connected: () => this.connected,
             reSubmit: this.reSubmit.bind(this),
-            orderSequentially: this.orderSequentially.bind(this),
-        }, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pending);
+            reSubmitBatch: this.reSubmitBatch.bind(this),
+            isActiveConnection: () => this.innerDeltaManager.active,
+        }, pendingRuntimeState?.pending, this.logger);
         const disableCompression = this.mc.config.getBoolean("Fluid.ContainerRuntime.CompressionDisabled");
         const compressionOptions = disableCompression === true
             ? {
@@ -358,16 +405,19 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
             : runtimeOptions.compressionOptions;
         const disablePartialFlush = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisablePartialFlush");
+        const legacySendBatchFn = makeLegacySendBatchFn(this.submitFn, this.innerDeltaManager);
         this.outbox = new Outbox({
             shouldSend: () => this.canSendOps(),
             pendingStateManager: this.pendingStateManager,
-            containerContext: this.context,
+            submitBatchFn: this.submitBatchFn,
+            legacySendBatchFn,
             compressor: new OpCompressor(this.mc.logger),
             splitter: opSplitter,
             config: {
                 compressionOptions,
                 maxBatchSizeInBytes: runtimeOptions.maxBatchSizeInBytes,
                 disablePartialFlush: disablePartialFlush === true,
+                enableGroupedBatching: this.groupedBatchingEnabled,
             },
             logger: this.mc.logger,
             groupingManager: opGroupingManager,
@@ -375,43 +425,54 @@ export class ContainerRuntime extends TypedEventEmitter {
                 referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
                 clientSequenceNumber: this._processedClientSequenceNumber,
             }),
+            reSubmit: this.reSubmit.bind(this),
+            opReentrancy: () => this.ensureNoDataModelChangesCalls > 0,
+            closeContainer: this.closeFn,
         });
-        this.context.quorum.on("removeMember", (clientId) => {
+        this._quorum = quorum;
+        this._quorum.on("removeMember", (clientId) => {
             this.remoteMessageProcessor.clearPartialMessagesFor(clientId);
         });
-        this.summaryStateUpdateMethod = this.mc.config.getString("Fluid.ContainerRuntime.Test.SummaryStateUpdateMethod");
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this._audience = audience;
         const closeSummarizerDelayOverride = this.mc.config.getNumber("Fluid.ContainerRuntime.Test.CloseSummarizerDelayOverrideMs");
-        this.closeSummarizerDelayMs = closeSummarizerDelayOverride !== null && closeSummarizerDelayOverride !== void 0 ? closeSummarizerDelayOverride : defaultCloseSummarizerDelayMs;
+        this.closeSummarizerDelayMs = closeSummarizerDelayOverride ?? defaultCloseSummarizerDelayMs;
+        this.validateSummaryBeforeUpload =
+            this.mc.config.getBoolean("Fluid.Summarizer.ValidateSummaryBeforeUpload") ?? false;
         this.summaryCollection = new SummaryCollection(this.deltaManager, this.logger);
         this.dirtyContainer =
-            this.context.attachState !== AttachState.Attached ||
-                this.pendingStateManager.hasPendingMessages();
-        this.context.updateDirtyContainerState(this.dirtyContainer);
+            this.attachState !== AttachState.Attached || this.hasPendingMessages();
+        context.updateDirtyContainerState(this.dirtyContainer);
         if (this.summariesDisabled) {
             this.mc.logger.sendTelemetryEvent({ eventName: "SummariesDisabled" });
         }
         else {
-            const orderedClientLogger = ChildLogger.create(this.logger, "OrderedClientElection");
-            const orderedClientCollection = new OrderedClientCollection(orderedClientLogger, this.context.deltaManager, this.context.quorum);
-            const orderedClientElectionForSummarizer = new OrderedClientElection(orderedClientLogger, orderedClientCollection, electedSummarizerData !== null && electedSummarizerData !== void 0 ? electedSummarizerData : this.context.deltaManager.lastSequenceNumber, SummarizerClientElection.isClientEligible);
+            const orderedClientLogger = createChildLogger({
+                logger: this.logger,
+                namespace: "OrderedClientElection",
+            });
+            const orderedClientCollection = new OrderedClientCollection(orderedClientLogger, this.innerDeltaManager, this._quorum);
+            const orderedClientElectionForSummarizer = new OrderedClientElection(orderedClientLogger, orderedClientCollection, electedSummarizerData ?? this.innerDeltaManager.lastSequenceNumber, SummarizerClientElection.isClientEligible);
             this.summarizerClientElection = new SummarizerClientElection(orderedClientLogger, this.summaryCollection, orderedClientElectionForSummarizer, this.maxOpsSinceLastSummary);
-            if (this.context.clientDetails.type === summarizerClientType) {
+            if (this.isSummarizerClient) {
                 this._summarizer = new Summarizer(this /* ISummarizerRuntime */, () => this.summaryConfiguration, this /* ISummarizerInternalsProvider */, this.handleContext, this.summaryCollection, async (runtime) => RunWhileConnectedCoordinator.create(runtime, 
                 // Summarization runs in summarizer client and needs access to the real (non-proxy) active
                 // information. The proxy delta manager would always return false for summarizer client.
                 () => this.innerDeltaManager.active));
             }
-            else if (SummarizerClientElection.clientDetailsPermitElection(this.context.clientDetails)) {
+            else if (SummarizerClientElection.clientDetailsPermitElection(this.clientDetails)) {
                 // Only create a SummaryManager and SummarizerClientElection
                 // if summaries are enabled and we are not the summarizer client.
                 const defaultAction = () => {
                     if (this.summaryCollection.opsSinceLastAck > this.maxOpsSinceLastSummary) {
-                        this.logger.sendTelemetryEvent({ eventName: "SummaryStatus:Behind" });
+                        this.mc.logger.sendTelemetryEvent({ eventName: "SummaryStatus:Behind" });
                         // unregister default to no log on every op after falling behind
                         // and register summary ack handler to re-register this handler
                         // after successful summary
                         this.summaryCollection.once(MessageType.SummaryAck, () => {
-                            this.logger.sendTelemetryEvent({ eventName: "SummaryStatus:CaughtUp" });
+                            this.mc.logger.sendTelemetryEvent({
+                                eventName: "SummaryStatus:CaughtUp",
+                            });
                             // we've caught up, so re-register the default action to monitor for
                             // falling behind, and unregister ourself
                             this.summaryCollection.on("default", defaultAction);
@@ -422,12 +483,15 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.summaryCollection.on("default", defaultAction);
                 // Create the SummaryManager and mark the initial state
                 this.summaryManager = new SummaryManager(this.summarizerClientElection, this, // IConnectedState
-                this.summaryCollection, this.logger, this.formRequestSummarizerFn(this.context.loader), new Throttler(60 * 1000, // 60 sec delay window
+                this.summaryCollection, this.logger, this.formRequestSummarizerFn(loader), new Throttler(60 * 1000, // 60 sec delay window
                 30 * 1000, // 30 sec max delay
                 // throttling function increases exponentially (0ms, 40ms, 80ms, 160ms, etc)
                 formExponentialFn({ coefficient: 20, initialDelay: 0 })), {
                     initialDelayMs: this.initialSummarizerDelayMs,
                 }, this.heuristicsDisabled);
+                this.summaryManager.on("summarize", (eventProps) => {
+                    this.emit("summarize", eventProps);
+                });
                 this.summaryManager.start();
             }
         }
@@ -452,27 +516,44 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.replayPendingStates();
         });
         // logging hardware telemetry
-        logger.sendTelemetryEvent(Object.assign({ eventName: "DeviceSpec" }, getDeviceSpec()));
-        this.logger.sendTelemetryEvent(Object.assign(Object.assign(Object.assign({ eventName: "ContainerLoadStats" }, this.createContainerMetadata), this.dataStores.containerLoadStats), { summaryNumber: loadSummaryNumber, summaryFormatVersion: metadata === null || metadata === void 0 ? void 0 : metadata.summaryFormatVersion, disableIsolatedChannels: metadata === null || metadata === void 0 ? void 0 : metadata.disableIsolatedChannels, gcVersion: metadata === null || metadata === void 0 ? void 0 : metadata.gcFeature, options: JSON.stringify(runtimeOptions), featureGates: JSON.stringify({
+        logger.sendTelemetryEvent({
+            eventName: "DeviceSpec",
+            ...getDeviceSpec(),
+        });
+        this.mc.logger.sendTelemetryEvent({
+            eventName: "ContainerLoadStats",
+            ...this.createContainerMetadata,
+            ...this.dataStores.containerLoadStats,
+            summaryNumber: loadSummaryNumber,
+            summaryFormatVersion: metadata?.summaryFormatVersion,
+            disableIsolatedChannels: metadata?.disableIsolatedChannels,
+            gcVersion: metadata?.gcFeature,
+            options: JSON.stringify(runtimeOptions),
+            featureGates: JSON.stringify({
                 disableCompression,
                 disableOpReentryCheck,
                 disableChunking,
                 disableAttachReorder: this.disableAttachReorder,
                 disablePartialFlush,
                 idCompressorEnabled: this.idCompressorEnabled,
-                summaryStateUpdateMethod: this.summaryStateUpdateMethod,
                 closeSummarizerDelayOverride,
-            }), telemetryDocumentId: this.telemetryDocumentId, groupedBatchingEnabled: this.groupedBatchingEnabled }));
-        ReportOpPerfTelemetry(this.context.clientId, this.deltaManager, this.logger);
+            }),
+            telemetryDocumentId: this.telemetryDocumentId,
+            groupedBatchingEnabled: this.groupedBatchingEnabled,
+        });
+        ReportOpPerfTelemetry(this.clientId, this.deltaManager, this.logger);
         BindBatchTracker(this, this.logger);
         this.entryPoint = new LazyPromise(async () => {
-            if (this.context.clientDetails.type === summarizerClientType) {
+            if (this.isSummarizerClient) {
                 assert(this._summarizer !== undefined, 0x5bf /* Summarizer object is undefined in a summarizer client */);
                 return this._summarizer;
             }
-            return initializeEntryPoint === null || initializeEntryPoint === void 0 ? void 0 : initializeEntryPoint(this);
+            return initializeEntryPoint?.(this);
         });
     }
+    /**
+     * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
     get IFluidRouter() {
         return this;
     }
@@ -518,22 +599,34 @@ export class ContainerRuntime extends TypedEventEmitter {
      * This object should provide all the functionality that the Container is expected to provide to the loader layer.
      */
     static async loadRuntime(params) {
-        var _a, _b, _c, _d, _e, _f;
-        const { context, registryEntries, existing, requestHandler, runtimeOptions = {}, containerScope = {}, containerRuntimeCtor = ContainerRuntime, initializeEntryPoint, } = params;
+        const { context, registryEntries, existing, requestHandler, runtimeOptions = {}, containerScope = {}, containerRuntimeCtor = ContainerRuntime, } = params;
+        const initializeEntryPoint = params.initializeEntryPoint ??
+            (async (containerRuntime) => ({
+                get IFluidRouter() {
+                    return this;
+                },
+                async request(req) {
+                    return containerRuntime.request(req);
+                },
+            }));
         // If taggedLogger exists, use it. Otherwise, wrap the vanilla logger:
         // back-compat: Remove the TaggedLoggerAdapter fallback once all the host are using loader > 0.45
         const backCompatContext = context;
-        const passLogger = (_a = backCompatContext.taggedLogger) !== null && _a !== void 0 ? _a : new TaggedLoggerAdapter(backCompatContext.logger);
-        const logger = ChildLogger.create(passLogger, undefined, {
-            all: {
-                runtimeVersion: pkgVersion,
+        const passLogger = backCompatContext.taggedLogger ??
+            // eslint-disable-next-line import/no-deprecated
+            new TaggedLoggerAdapter(backCompatContext.logger);
+        const logger = createChildLogger({
+            logger: passLogger,
+            properties: {
+                all: {
+                    runtimeVersion: pkgVersion,
+                },
             },
         });
         const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, compressionOptions = defaultCompressionConfig, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, enableRuntimeIdCompressor = false, chunkSizeInBytes = defaultChunkSizeInBytes, enableOpReentryCheck = false, enableGroupedBatching = false, } = runtimeOptions;
         const registry = new FluidDataStoreRegistry(registryEntries);
         const tryFetchBlob = async (blobName) => {
-            var _a;
-            const blobId = (_a = context.baseSnapshot) === null || _a === void 0 ? void 0 : _a.blobs[blobName];
+            const blobId = context.baseSnapshot?.blobs[blobName];
             if (context.baseSnapshot && blobId) {
                 // IContainerContext storage api return type still has undefined in 0.39 package version.
                 // So once we release 0.40 container-defn package we can remove this check.
@@ -548,16 +641,15 @@ export class ContainerRuntime extends TypedEventEmitter {
             tryFetchBlob(aliasBlobName),
             tryFetchBlob(idCompressorBlobName),
         ]);
-        const loadExisting = existing === true || context.existing === true;
         // read snapshot blobs needed for BlobManager to load
-        const blobManagerSnapshot = await BlobManager.load((_b = context.baseSnapshot) === null || _b === void 0 ? void 0 : _b.trees[blobsTreeName], async (id) => {
+        const blobManagerSnapshot = await BlobManager.load(context.baseSnapshot?.trees[blobsTreeName], async (id) => {
             // IContainerContext storage api return type still has undefined in 0.39 package version.
             // So once we release 0.40 container-defn package we can remove this check.
             assert(context.storage !== undefined, 0x256 /* "storage undefined in attached container" */);
             return readAndParse(context.storage, id);
         });
         // Verify summary runtime sequence number matches protocol sequence number.
-        const runtimeSequenceNumber = (_c = metadata === null || metadata === void 0 ? void 0 : metadata.message) === null || _c === void 0 ? void 0 : _c.sequenceNumber;
+        const runtimeSequenceNumber = metadata?.message?.sequenceNumber;
         // When we load with pending state, we reuse an old snapshot so we don't expect these numbers to match
         if (!context.pendingLocalState && runtimeSequenceNumber !== undefined) {
             const protocolSequenceNumber = context.deltaManager.initialSequenceNumber;
@@ -572,22 +664,20 @@ export class ContainerRuntime extends TypedEventEmitter {
                     logger.sendErrorEvent({ eventName: "SequenceNumberMismatch" }, error);
                 }
                 else {
-                    // Call both close and dispose as closeFn implementation will no longer dispose runtime in future
                     context.closeFn(error);
-                    (_d = context.disposeFn) === null || _d === void 0 ? void 0 : _d.call(context, error);
                 }
             }
         }
-        const idCompressorEnabled = (_f = (_e = metadata === null || metadata === void 0 ? void 0 : metadata.idCompressorEnabled) !== null && _e !== void 0 ? _e : runtimeOptions.enableRuntimeIdCompressor) !== null && _f !== void 0 ? _f : false;
+        const idCompressorEnabled = metadata?.idCompressorEnabled ?? runtimeOptions.enableRuntimeIdCompressor ?? false;
         let idCompressor;
         if (idCompressorEnabled) {
             const { IdCompressor, createSessionId } = await import("./id-compressor");
             idCompressor =
                 serializedIdCompressor !== undefined
                     ? IdCompressor.deserialize(serializedIdCompressor, createSessionId())
-                    : new IdCompressor(createSessionId(), logger);
+                    : IdCompressor.create(logger);
         }
-        const runtime = new containerRuntimeCtor(context, registry, metadata, electedSummarizerData, chunks !== null && chunks !== void 0 ? chunks : [], aliases !== null && aliases !== void 0 ? aliases : [], {
+        const runtime = new containerRuntimeCtor(context, registry, metadata, electedSummarizerData, chunks ?? [], aliases ?? [], {
             summaryOptions,
             gcOptions,
             loadSequenceNumberVerification,
@@ -598,8 +688,9 @@ export class ContainerRuntime extends TypedEventEmitter {
             enableRuntimeIdCompressor,
             enableOpReentryCheck,
             enableGroupedBatching,
-        }, containerScope, logger, loadExisting, blobManagerSnapshot, context.storage, idCompressor, requestHandler, undefined, // summaryConfiguration
+        }, containerScope, logger, existing, blobManagerSnapshot, context.storage, idCompressor, requestHandler, undefined, // summaryConfiguration
         initializeEntryPoint);
+        await runtime.blobManager.processStashedChanges();
         // It's possible to have ops with a reference sequence number of 0. Op sequence numbers start
         // at 1, so we won't see a replayed saved op with a sequence number of 0.
         await runtime.pendingStateManager.applyStashedOpsAt(0);
@@ -607,34 +698,16 @@ export class ContainerRuntime extends TypedEventEmitter {
         await runtime.initializeBaseState();
         return runtime;
     }
-    get options() {
-        return this.context.options;
-    }
     get clientId() {
-        return this.context.clientId;
-    }
-    get clientDetails() {
-        return this.context.clientDetails;
+        return this._getClientId();
     }
     get storage() {
         return this._storage;
     }
+    /** @deprecated - The functionality is no longer exposed publicly */
     get reSubmitFn() {
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        return this.reSubmitCore;
-    }
-    get disposeFn() {
-        var _a;
-        // In old loaders without dispose functionality, closeFn is equivalent but will also switch container to readonly mode
-        return (_a = this.context.disposeFn) !== null && _a !== void 0 ? _a : this.context.closeFn;
-    }
-    get closeFn() {
-        // Also call disposeFn to retain functionality of runtime being disposed on close
-        return (error) => {
-            var _a, _b;
-            this.context.closeFn(error);
-            (_b = (_a = this.context).disposeFn) === null || _b === void 0 ? void 0 : _b.call(_a, error);
-        };
+        return (type, contents, localOpMetadata, opMetadata) => this.reSubmitCore({ type, contents }, localOpMetadata, opMetadata);
+        // Note: compatDetails is not included in this deprecated API
     }
     get flushMode() {
         return this._flushMode;
@@ -646,7 +719,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         return this.registry;
     }
     get attachState() {
-        return this.context.attachState;
+        return this._getAttachState();
     }
     get IFluidHandleContext() {
         return this.handleContext;
@@ -673,8 +746,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     /** clientId of parent (non-summarizing) container that owns summarizer container */
     get summarizerClientId() {
-        var _a;
-        return (_a = this.summarizerClientElection) === null || _a === void 0 ? void 0 : _a.electedClientId;
+        return this.summarizerClientElection?.electedClientId;
     }
     get disposed() {
         return this._disposed;
@@ -711,12 +783,11 @@ export class ContainerRuntime extends TypedEventEmitter {
         await this.garbageCollector.initializeBaseState();
     }
     dispose(error) {
-        var _a;
         if (this._disposed) {
             return;
         }
         this._disposed = true;
-        this.logger.sendTelemetryEvent({
+        this.mc.logger.sendTelemetryEvent({
             eventName: "ContainerRuntimeDisposed",
             isDirty: this.isDirty,
             lastSequenceNumber: this.deltaManager.lastSequenceNumber,
@@ -726,7 +797,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.summaryManager.dispose();
         }
         this.garbageCollector.dispose();
-        (_a = this._summarizer) === null || _a === void 0 ? void 0 : _a.dispose();
+        this._summarizer?.dispose();
         this.dataStores.dispose();
         this.pendingStateManager.dispose();
         this.emit("dispose");
@@ -735,6 +806,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     /**
      * Notifies this object about the request made to the container.
      * @param request - Request made to the handler.
+     * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
      */
     async request(request) {
         try {
@@ -786,7 +858,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // We always expect createSubRequest to include a leading slash, but asserting here to protect against
                 // unintentionally modifying the url if that changes.
                 assert(subRequest.url.startsWith("/"), 0x126 /* "Expected createSubRequest url to include a leading slash" */);
-                return dataStore.IFluidRouter.request(subRequest);
+                return dataStore.request(subRequest);
             }
             return create404Response(request);
         }
@@ -801,19 +873,17 @@ export class ContainerRuntime extends TypedEventEmitter {
         return this.entryPoint;
     }
     internalId(maybeAlias) {
-        var _a;
-        return (_a = this.dataStores.aliases.get(maybeAlias)) !== null && _a !== void 0 ? _a : maybeAlias;
+        return this.dataStores.aliases.get(maybeAlias) ?? maybeAlias;
     }
     async getDataStoreFromRequest(id, request) {
-        var _a, _b, _c;
         const headerData = {};
-        if (typeof ((_a = request.headers) === null || _a === void 0 ? void 0 : _a[RuntimeHeaders.wait]) === "boolean") {
+        if (typeof request.headers?.[RuntimeHeaders.wait] === "boolean") {
             headerData.wait = request.headers[RuntimeHeaders.wait];
         }
-        if (typeof ((_b = request.headers) === null || _b === void 0 ? void 0 : _b[RuntimeHeaders.viaHandle]) === "boolean") {
+        if (typeof request.headers?.[RuntimeHeaders.viaHandle] === "boolean") {
             headerData.viaHandle = request.headers[RuntimeHeaders.viaHandle];
         }
-        if (typeof ((_c = request.headers) === null || _c === void 0 ? void 0 : _c[AllowTombstoneRequestHeaderKey]) === "boolean") {
+        if (typeof request.headers?.[AllowTombstoneRequestHeaderKey] === "boolean") {
             headerData.allowTombstone = request.headers[AllowTombstoneRequestHeaderKey];
         }
         await this.dataStores.waitIfPendingAlias(id);
@@ -823,22 +893,27 @@ export class ContainerRuntime extends TypedEventEmitter {
         // Remove query params, leading and trailing slashes from the url. This is done to make sure the format is
         // the same as GC nodes id.
         const urlWithoutQuery = trimLeadingAndTrailingSlashes(request.url.split("?")[0]);
-        this.garbageCollector.nodeUpdated(`/${urlWithoutQuery}`, "Loaded", undefined /* timestampMs */, dataStoreContext.packagePath, request === null || request === void 0 ? void 0 : request.headers);
+        this.garbageCollector.nodeUpdated(`/${urlWithoutQuery}`, "Loaded", undefined /* timestampMs */, dataStoreContext.packagePath, request?.headers);
         return dataStoreChannel;
     }
     /** Adds the container's metadata to the given summary tree. */
     addMetadataToSummary(summaryTree) {
-        var _a;
-        const metadata = Object.assign(Object.assign(Object.assign(Object.assign({}, this.createContainerMetadata), { 
+        const metadata = {
+            ...this.createContainerMetadata,
             // Increment the summary number for the next summary that will be generated.
-            summaryNumber: this.nextSummaryNumber++, summaryFormatVersion: 1 }), this.garbageCollector.getMetadata()), { 
+            summaryNumber: this.nextSummaryNumber++,
+            summaryFormatVersion: 1,
+            ...this.garbageCollector.getMetadata(),
             // The last message processed at the time of summary. If there are no new messages, use the message from the
             // last summary.
-            message: (_a = extractSummaryMetadataMessage(this.deltaManager.lastMessage)) !== null && _a !== void 0 ? _a : this.messageAtLastSummary, telemetryDocumentId: this.telemetryDocumentId, idCompressorEnabled: this.idCompressorEnabled ? true : undefined });
+            message: extractSummaryMetadataMessage(this.deltaManager.lastMessage) ??
+                this.messageAtLastSummary,
+            telemetryDocumentId: this.telemetryDocumentId,
+            idCompressorEnabled: this.idCompressorEnabled ? true : undefined,
+        };
         addBlobToSummary(summaryTree, metadataBlobName, JSON.stringify(metadata));
     }
     addContainerStateToSummary(summaryTree, fullTree, trackState, telemetryContext) {
-        var _a;
         this.addMetadataToSummary(summaryTree);
         if (this.idCompressorEnabled) {
             assert(this.idCompressor !== undefined, 0x67a /* IdCompressor should be defined if enabled */);
@@ -854,7 +929,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             addBlobToSummary(summaryTree, aliasBlobName, JSON.stringify([...dataStoreAliases]));
         }
         if (this.summarizerClientElection) {
-            const electedSummarizerContent = JSON.stringify((_a = this.summarizerClientElection) === null || _a === void 0 ? void 0 : _a.serialize());
+            const electedSummarizerContent = JSON.stringify(this.summarizerClientElection?.serialize());
             addBlobToSummary(summaryTree, electedSummarizerBlobName, electedSummarizerContent);
         }
         const blobManagerSummary = this.blobManager.summarize();
@@ -891,7 +966,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.mc.logger.sendTelemetryEvent({
                 eventName: "ReconnectsWithNoProgress",
                 attempts: this.consecutiveReconnects,
-                pendingMessages: this.pendingStateManager.pendingMessagesCount,
+                pendingMessages: this.pendingMessagesCount,
             });
         }
         return this.consecutiveReconnects < this.maxConsecutiveReconnects;
@@ -901,7 +976,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         // in their own batches before the originating batch is sent.
         // Therefore, receiving them while attempting to send the originating batch
         // does not mean that the container is making any progress.
-        if ((message === null || message === void 0 ? void 0 : message.type) !== ContainerMessageType.ChunkedOp) {
+        if (message?.type !== ContainerMessageType.ChunkedOp) {
             this.consecutiveReconnects = 0;
         }
     }
@@ -951,13 +1026,13 @@ export class ContainerRuntime extends TypedEventEmitter {
      */
     parseOpContent(serializedContent) {
         assert(serializedContent !== undefined, 0x6d5 /* content must be defined */);
-        const parsed = JSON.parse(serializedContent);
-        assert(parsed.type !== undefined, 0x6d6 /* incorrect op content format */);
-        return { type: parsed.type, contents: parsed.contents };
+        const { type, contents, compatDetails } = JSON.parse(serializedContent);
+        assert(type !== undefined, 0x6d6 /* incorrect op content format */);
+        return { type, contents, compatDetails };
     }
     async applyStashedOp(op) {
         // Need to parse from string for back-compat
-        const { type, contents } = this.parseOpContent(op);
+        const { type, contents, compatDetails } = this.parseOpContent(op);
         switch (type) {
             case ContainerMessageType.FluidDataStoreOp:
                 return this.dataStores.applyStashedOp(contents);
@@ -973,8 +1048,22 @@ export class ContainerRuntime extends TypedEventEmitter {
                 throw new Error("chunkedOp not expected here");
             case ContainerMessageType.Rejoin:
                 throw new Error("rejoin not expected here");
-            default:
-                unreachableCase(type, `Unknown ContainerMessageType: ${type}`);
+            default: {
+                // This should be extremely rare for stashed ops.
+                // It would require a newer runtime stashing ops and then an older one applying them,
+                // e.g. if an app rolled back its container version
+                const compatBehavior = compatDetails?.behavior;
+                if (!compatBehaviorAllowsMessageType(type, compatBehavior)) {
+                    const error = DataProcessingError.create("Stashed runtime message of unknown type", "applyStashedOp", undefined /* sequencedMessage */, {
+                        messageDetails: JSON.stringify({
+                            type,
+                            compatBehavior,
+                        }),
+                    });
+                    this.closeFn(error);
+                    throw error;
+                }
+            }
         }
     }
     setConnectionState(connected, clientId) {
@@ -986,24 +1075,6 @@ export class ContainerRuntime extends TypedEventEmitter {
             // Don't propagate "disconnected" event because we didn't propagate the previous "connected" event
             return;
         }
-        // If attachment blobs were added while disconnected, we need to delay
-        // propagation of the "connected" event until we have uploaded them to
-        // ensure we don't submit ops referencing a blob that has not been uploaded
-        // Note that the inner (non-proxy) delta manager is needed here to get the readonly information.
-        const connecting = connected && !this._connected && !this.innerDeltaManager.readOnlyInfo.readonly;
-        if (connecting && this.blobManager.hasPendingOfflineUploads) {
-            assert(!this.delayConnectClientId, 0x392 /* Connect event delay must be canceled before subsequent connect event */);
-            assert(!!clientId, 0x393 /* Must have clientId when connecting */);
-            this.delayConnectClientId = clientId;
-            this.blobManager.onConnected().then(() => {
-                // make sure we didn't reconnect before the promise resolved
-                if (this.delayConnectClientId === clientId && !this.disposed) {
-                    this.delayConnectClientId = undefined;
-                    this.setConnectionStateCore(connected, clientId);
-                }
-            }, (error) => this.closeFn(error));
-            return;
-        }
         this.setConnectionStateCore(connected, clientId);
     }
     setConnectionStateCore(connected, clientId) {
@@ -1012,6 +1083,12 @@ export class ContainerRuntime extends TypedEventEmitter {
         // There might be no change of state due to Container calling this API after loading runtime.
         const changeOfState = this._connected !== connected;
         const reconnection = changeOfState && !connected;
+        // We need to flush the ops currently collected by Outbox to preserve original order.
+        // This flush NEEDS to happen before we set the ContainerRuntime to "connected".
+        // We want these ops to get to the PendingStateManager without sending to service and have them return to the Outbox upon calling "replayPendingStates".
+        if (changeOfState && connected) {
+            this.flush();
+        }
         this._connected = connected;
         if (!connected) {
             this._perfSignalData.signalsLost = 0;
@@ -1028,7 +1105,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.closeFn(DataProcessingError.create("Runtime detected too many reconnects with no progress syncing local ops.", "setConnectionState", undefined, {
                     dataLoss: 1,
                     attempts: this.consecutiveReconnects,
-                    pendingMessages: this.pendingStateManager.pendingMessagesCount,
+                    pendingMessages: this.pendingMessagesCount,
                 }));
                 return;
             }
@@ -1045,18 +1122,23 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     process(messageArg, local) {
         this.verifyNotClosed();
-        // Whether or not the message is actually a runtime message.
+        // Whether or not the message appears to be a runtime message from an up-to-date client.
         // It may be a legacy runtime message (ie already unpacked and ContainerMessageType)
         // or something different, like a system message.
-        const runtimeMessage = messageArg.type === MessageType.Operation;
+        const modernRuntimeMessage = messageArg.type === MessageType.Operation;
         // Do shallow copy of message, as the processing flow will modify it.
-        const messageCopy = Object.assign({}, messageArg);
+        const messageCopy = { ...messageArg };
         for (const message of this.remoteMessageProcessor.process(messageCopy)) {
-            this.processCore(message, local, runtimeMessage);
+            this.processCore(message, local, modernRuntimeMessage);
         }
     }
-    processCore(message, local, runtimeMessage) {
-        var _a;
+    /**
+     * Direct the message to the correct subsystem for processing, and implement other side effects
+     * @param message - The unpacked message. Likely a ContainerRuntimeMessage, but could also be a system op
+     * @param local - Did this client send the op?
+     * @param modernRuntimeMessage - Does this appear like a current ContainerRuntimeMessage?
+     */
+    processCore(message, local, modernRuntimeMessage) {
         // Surround the actual processing of the operation with messages to the schedule manager indicating
         // the beginning and end. This allows it to emit appropriate events and/or pause the processing of new
         // messages once a batch has been fully processed.
@@ -1064,7 +1146,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         this._processedClientSequenceNumber = message.clientSequenceNumber;
         try {
             let localOpMetadata;
-            if (local && runtimeMessage && message.type !== ContainerMessageType.ChunkedOp) {
+            if (local && modernRuntimeMessage && message.type !== ContainerMessageType.ChunkedOp) {
                 localOpMetadata = this.pendingStateManager.processPendingLocalMessage(message);
             }
             // If there are no more pending messages after processing a local message,
@@ -1072,45 +1154,8 @@ export class ContainerRuntime extends TypedEventEmitter {
             if (!this.hasPendingMessages()) {
                 this.updateDocumentDirtyState(false);
             }
-            const type = message.type;
-            switch (type) {
-                case ContainerMessageType.Attach:
-                    this.dataStores.processAttachMessage(message, local);
-                    break;
-                case ContainerMessageType.Alias:
-                    this.processAliasMessage(message, localOpMetadata, local);
-                    break;
-                case ContainerMessageType.FluidDataStoreOp:
-                    this.dataStores.processFluidDataStoreOp(message, local, localOpMetadata);
-                    break;
-                case ContainerMessageType.BlobAttach:
-                    this.blobManager.processBlobAttachOp(message, local);
-                    break;
-                case ContainerMessageType.IdAllocation:
-                    assert(this.idCompressor !== undefined, 0x67c /* IdCompressor should be defined if enabled */);
-                    this.idCompressor.finalizeCreationRange(message.contents);
-                    break;
-                case ContainerMessageType.ChunkedOp:
-                case ContainerMessageType.Rejoin:
-                    break;
-                default:
-                    if (runtimeMessage) {
-                        const error = DataProcessingError.create(
-                        // Former assert 0x3ce
-                        "Runtime message of unknown type", "OpProcessing", message, {
-                            local,
-                            type: message.type,
-                            contentType: typeof message.contents,
-                            batch: (_a = message.metadata) === null || _a === void 0 ? void 0 : _a.batch,
-                            compression: message.compression,
-                        });
-                        this.closeFn(error);
-                        throw error;
-                    }
-            }
-            if (runtimeMessage || this.groupedBatchingEnabled) {
-                this.emit("op", message, runtimeMessage);
-            }
+            this.validateAndProcessRuntimeMessage(message, localOpMetadata, local, modernRuntimeMessage);
+            this.emit("op", message, modernRuntimeMessage);
             this.scheduleManager.afterOpProcessing(undefined, message);
             if (local) {
                 // If we have processed a local op, this means that the container is
@@ -1124,8 +1169,59 @@ export class ContainerRuntime extends TypedEventEmitter {
             throw e;
         }
     }
-    processAliasMessage(message, localOpMetadata, local) {
-        this.dataStores.processAliasMessage(message, localOpMetadata, local);
+    /**
+     * Assuming the given message is also a ContainerRuntimeMessage,
+     * checks its type and dispatches the message to the appropriate handler in the runtime.
+     * Throws a DataProcessingError if the message doesn't conform to the ContainerRuntimeMessage type.
+     */
+    validateAndProcessRuntimeMessage(message, localOpMetadata, local, expectRuntimeMessageType) {
+        // Optimistically extract ContainerRuntimeMessage-specific props from the message
+        const { type: maybeContainerMessageType, compatDetails } = message;
+        switch (maybeContainerMessageType) {
+            case ContainerMessageType.Attach:
+                this.dataStores.processAttachMessage(message, local);
+                break;
+            case ContainerMessageType.Alias:
+                this.dataStores.processAliasMessage(message, localOpMetadata, local);
+                break;
+            case ContainerMessageType.FluidDataStoreOp:
+                this.dataStores.processFluidDataStoreOp(message, local, localOpMetadata);
+                break;
+            case ContainerMessageType.BlobAttach:
+                this.blobManager.processBlobAttachOp(message, local);
+                break;
+            case ContainerMessageType.IdAllocation:
+                assert(this.idCompressor !== undefined, 0x67c /* IdCompressor should be defined if enabled */);
+                this.idCompressor.finalizeCreationRange(message.contents);
+                break;
+            case ContainerMessageType.ChunkedOp:
+            case ContainerMessageType.Rejoin:
+                break;
+            default: {
+                // If we didn't necessarily expect a runtime message type, then no worries - just return
+                // e.g. this case applies to system ops, or legacy ops that would have fallen into the above cases anyway.
+                if (!expectRuntimeMessageType) {
+                    return;
+                }
+                const compatBehavior = compatDetails?.behavior;
+                if (!compatBehaviorAllowsMessageType(maybeContainerMessageType, compatBehavior)) {
+                    const error = DataProcessingError.create(
+                    // Former assert 0x3ce
+                    "Runtime message of unknown type", "OpProcessing", message, {
+                        local,
+                        messageDetails: JSON.stringify({
+                            type: message.type,
+                            contentType: typeof message.contents,
+                            compatBehavior,
+                            batch: message.metadata?.batch,
+                            compression: message.compression,
+                        }),
+                    });
+                    this.closeFn(error);
+                    throw error;
+                }
+            }
+        }
     }
     /**
      * Emits the Signal event and update the perf signal data.
@@ -1133,7 +1229,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      */
     sendSignalTelemetryEvent(clientSignalSequenceNumber) {
         const duration = Date.now() - this._perfSignalData.signalTimestamp;
-        this.logger.sendPerformanceEvent({
+        this.mc.logger.sendPerformanceEvent({
             eventName: "SignalLatency",
             duration,
             signalsLost: this._perfSignalData.signalsLost,
@@ -1156,7 +1252,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                     this._perfSignalData.trackingSignalSequenceNumber) {
                 this._perfSignalData.signalsLost++;
                 this._perfSignalData.trackingSignalSequenceNumber = undefined;
-                this.logger.sendErrorEvent({
+                this.mc.logger.sendErrorEvent({
                     eventName: "SignalLost",
                     type: envelope.contents.type,
                     signalsLost: this._perfSignalData.signalsLost,
@@ -1180,6 +1276,12 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         this.dataStores.processSignal(envelope.address, transformed, local);
     }
+    /**
+     * Returns the runtime of the data store.
+     * @param id - Id supplied during creating the data store.
+     * @param wait - True if you want to wait for it.
+     * @deprecated - Use getAliasedDataStoreEntryPoint instead to get an aliased data store's entry point.
+     */
     async getRootDataStore(id, wait = true) {
         return this.getRootDataStoreChannel(id, wait);
     }
@@ -1241,9 +1343,25 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         return result;
     }
-    async createDataStore(pkg) {
-        const internalId = uuid();
-        return channelToDataStore(await this._createDataStore(pkg, internalId), internalId, this, this.dataStores, this.mc.logger);
+    /**
+     * Returns the aliased data store's entryPoint, given the alias.
+     * @param alias - The alias for the data store.
+     * @returns The data store's entry point ({@link @fluidframework/core-interfaces#IFluidHandle}) if it exists and is aliased.
+     * Returns undefined if no data store has been assigned the given alias.
+     */
+    async getAliasedDataStoreEntryPoint(alias) {
+        await this.dataStores.waitIfPendingAlias(alias);
+        const internalId = this.internalId(alias);
+        const context = await this.dataStores.getDataStoreIfAvailable(internalId, { wait: false });
+        // If the data store is not available or not an alias, return undefined.
+        if (context === undefined || !(await context.isRoot())) {
+            return undefined;
+        }
+        const channel = await context.realize();
+        if (channel.entryPoint === undefined) {
+            throw new UsageError("entryPoint must be defined on data store runtime for using getAliasedDataStoreEntryPoint");
+        }
+        return channel.entryPoint;
     }
     createDetachedRootDataStore(pkg, rootDataStoreId) {
         if (rootDataStoreId.includes("/")) {
@@ -1254,16 +1372,20 @@ export class ContainerRuntime extends TypedEventEmitter {
     createDetachedDataStore(pkg) {
         return this.dataStores.createDetachedDataStoreCore(pkg, false);
     }
-    async _createDataStoreWithProps(pkg, props, id = uuid()) {
-        const fluidDataStore = await this.dataStores
-            ._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id, props)
-            .realize();
-        return channelToDataStore(fluidDataStore, id, this, this.dataStores, this.mc.logger);
+    async createDataStore(pkg) {
+        const id = uuid();
+        return channelToDataStore(await this.dataStores
+            ._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id)
+            .realize(), id, this, this.dataStores, this.mc.logger);
     }
-    async _createDataStore(pkg, id = uuid(), props) {
-        return this.dataStores
+    /**
+     * @deprecated 0.16 Issue #1537, #3631
+     * @internal
+     */
+    async _createDataStoreWithProps(pkg, props, id = uuid()) {
+        return channelToDataStore(await this.dataStores
             ._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id, props)
-            .realize();
+            .realize(), id, this, this.dataStores, this.mc.logger);
     }
     canSendOps() {
         // Note that the real (non-proxy) delta manager is needed here to get the readonly info. This is because
@@ -1277,11 +1399,10 @@ export class ContainerRuntime extends TypedEventEmitter {
         return this.flushMode !== FlushMode.Immediate || this._orderSequentiallyCalls !== 0;
     }
     getQuorum() {
-        return this.context.quorum;
+        return this._quorum;
     }
     getAudience() {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return this.context.audience;
+        return this._audience;
     }
     /**
      * Returns true of container is dirty, i.e. there are some pending local changes that
@@ -1290,7 +1411,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     get isDirty() {
         return this.dirtyContainer;
     }
-    isContainerMessageDirtyable(type, contents) {
+    isContainerMessageDirtyable({ type, contents }) {
         // For legacy purposes, exclude the old built-in AgentScheduler from dirty consideration as a special-case.
         // Ultimately we should have no special-cases from the ContainerRuntime's perspective.
         if (type === ContainerMessageType.Attach) {
@@ -1330,11 +1451,11 @@ export class ContainerRuntime extends TypedEventEmitter {
     submitSignal(type, content) {
         this.verifyNotClosed();
         const envelope = this.createNewSignalEnvelope(undefined /* address */, type, content);
-        return this.context.submitSignalFn(envelope);
+        return this.submitSignalFn(envelope);
     }
     submitDataStoreSignal(address, type, content) {
         const envelope = this.createNewSignalEnvelope(address, type, content);
-        return this.context.submitSignalFn(envelope);
+        return this.submitSignalFn(envelope);
     }
     setAttachState(attachState) {
         if (attachState === AttachState.Attaching) {
@@ -1367,22 +1488,17 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.addContainerStateToSummary(summarizeResult, true /* fullTree */, false /* trackState */, telemetryContext);
         return summarizeResult.summary;
     }
-    async getAbsoluteUrl(relativeUrl) {
-        if (this.context.getAbsoluteUrl === undefined) {
-            throw new Error("Driver does not implement getAbsoluteUrl");
-        }
-        if (this.attachState !== AttachState.Attached) {
-            return undefined;
-        }
-        return this.context.getAbsoluteUrl(relativeUrl);
-    }
     async summarizeInternal(fullTree, trackState, telemetryContext) {
         const summarizeResult = await this.dataStores.summarize(fullTree, trackState, telemetryContext);
         // Wrap data store summaries in .channels subtree.
         wrapSummaryInChannelsTree(summarizeResult);
         const pathPartsForChildren = [channelsTreeName];
         this.addContainerStateToSummary(summarizeResult, fullTree, trackState, telemetryContext);
-        return Object.assign(Object.assign({}, summarizeResult), { id: "", pathPartsForChildren });
+        return {
+            ...summarizeResult,
+            id: "",
+            pathPartsForChildren,
+        };
     }
     /**
      * Returns a summary of the runtime at the current sequence number.
@@ -1400,16 +1516,15 @@ export class ContainerRuntime extends TypedEventEmitter {
             runSweep,
         });
         try {
-            let gcStats;
             if (runGC) {
-                gcStats = await this.collectGarbage({ logger: summaryLogger, runSweep, fullGC }, telemetryContext);
+                await this.collectGarbage({ logger: summaryLogger, runSweep, fullGC }, telemetryContext);
             }
             const { stats, summary } = await this.summarizerNode.summarize(fullTree, trackState, telemetryContext);
             assert(summary.type === SummaryType.Tree, 0x12f /* "Container Runtime's summarize should always return a tree" */);
-            return { stats, summary, gcStats };
+            return { stats, summary };
         }
         finally {
-            this.logger.sendTelemetryEvent({
+            this.mc.logger.sendTelemetryEvent({
                 eventName: "SummarizeTelemetry",
                 details: telemetryContext.serialize(),
             });
@@ -1471,7 +1586,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     /**
      * After GC has run and identified nodes that are sweep ready, this is called to delete the sweep ready nodes.
      * @param sweepReadyRoutes - The routes of nodes that are sweep ready and should be deleted.
-     * @returns - The routes of nodes that were deleted.
+     * @returns The routes of nodes that were deleted.
      */
     deleteSweepReadyNodes(sweepReadyRoutes) {
         const { dataStoreRoutes, blobManagerRoutes } = this.getDataStoreAndBlobManagerRoutes(sweepReadyRoutes);
@@ -1491,21 +1606,19 @@ export class ContainerRuntime extends TypedEventEmitter {
      * Returns a server generated referenced timestamp to be used to track unreferenced nodes by GC.
      */
     getCurrentReferenceTimestampMs() {
-        var _a, _b, _c;
         // Use the timestamp of the last message seen by this client as that is server generated. If no messages have
         // been processed, use the timestamp of the message from the last summary.
-        return (_b = (_a = this.deltaManager.lastMessage) === null || _a === void 0 ? void 0 : _a.timestamp) !== null && _b !== void 0 ? _b : (_c = this.messageAtLastSummary) === null || _c === void 0 ? void 0 : _c.timestamp;
+        return this.deltaManager.lastMessage?.timestamp ?? this.messageAtLastSummary?.timestamp;
     }
     /**
      * Returns the type of the GC node. Currently, there are nodes that belong to the root ("/"), data stores or
      * blob manager.
      */
     getNodeType(nodePath) {
-        var _a;
         if (this.isBlobPath(nodePath)) {
             return GCNodeType.Blob;
         }
-        return (_a = this.dataStores.getGCNodeType(nodePath)) !== null && _a !== void 0 ? _a : GCNodeType.Other;
+        return this.dataStores.getGCNodeType(nodePath) ?? GCNodeType.Other;
     }
     /**
      * Called by GC to retrieve the package path of the node with the given path. The node should belong to a
@@ -1535,7 +1648,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     /**
      * From a given list of routes, separate and return routes that belong to blob manager and data stores.
      * @param routes - A list of routes that can belong to data stores or blob manager.
-     * @returns - Two route lists - One that contains routes for blob manager and another one that contains routes
+     * @returns Two route lists - One that contains routes for blob manager and another one that contains routes
      * for data stores.
      */
     getDataStoreAndBlobManagerRoutes(routes) {
@@ -1576,23 +1689,62 @@ export class ContainerRuntime extends TypedEventEmitter {
      * @param options - options controlling how the summary is generated or submitted
      */
     async submitSummary(options) {
-        var _a, _b, _c;
-        const { fullTree = false, refreshLatestAck, summaryLogger } = options;
+        const { fullTree = false, finalAttempt = false, refreshLatestAck, summaryLogger } = options;
         // The summary number for this summary. This will be updated during the summary process, so get it now and
         // use it for all events logged during this summary.
         const summaryNumber = this.nextSummaryNumber;
-        const summaryNumberLogger = ChildLogger.create(summaryLogger, undefined, {
-            all: { summaryNumber },
+        const summaryNumberLogger = createChildLogger({
+            logger: summaryLogger,
+            properties: {
+                all: { summaryNumber },
+            },
         });
         assert(this.outbox.isEmpty, 0x3d1 /* Can't trigger summary in the middle of a batch */);
         let latestSnapshotVersionId;
         if (refreshLatestAck) {
-            const latestSnapshotInfo = await this.refreshLatestSummaryAckFromServer(ChildLogger.create(summaryNumberLogger, undefined, { all: { safeSummary: true } }));
+            const latestSnapshotInfo = await this.refreshLatestSummaryAckFromServer(createChildLogger({
+                logger: summaryNumberLogger,
+                properties: { all: { safeSummary: true } },
+            }));
             const latestSnapshotRefSeq = latestSnapshotInfo.latestSnapshotRefSeq;
             latestSnapshotVersionId = latestSnapshotInfo.latestSnapshotVersionId;
             // We might need to catch up to the latest summary's reference sequence number before pausing.
             await this.waitForDeltaManagerToCatchup(latestSnapshotRefSeq, summaryNumberLogger);
         }
+        // If there are pending (unacked ops), the summary will not be eventual consistent and it may even be
+        // incorrect. So, wait for the container to be saved with a timeout. If the container is not saved
+        // within the timeout, check if it should be failed or can continue.
+        if (this.validateSummaryBeforeUpload && this.hasPendingMessages()) {
+            const countBefore = this.pendingMessagesCount;
+            // The timeout for waiting for pending ops can be overridden via configurations.
+            const pendingOpsTimeout = this.mc.config.getNumber("Fluid.Summarizer.waitForPendingOpsTimeoutMs") ??
+                defaultPendingOpsWaitTimeoutMs;
+            await new Promise((resolve, reject) => {
+                const timeoutId = setTimeout(() => resolve(), pendingOpsTimeout);
+                this.once("saved", () => {
+                    clearTimeout(timeoutId);
+                    resolve();
+                });
+                this.once("dispose", () => {
+                    clearTimeout(timeoutId);
+                    reject(new Error("Runtime is disposed while summarizing"));
+                });
+            });
+            // Log that there are pending ops while summarizing. This will help us gather data on how often this
+            // happens, whether we attempted to wait for these ops to be acked and what was the result.
+            summaryNumberLogger.sendTelemetryEvent({
+                eventName: "PendingOpsWhileSummarizing",
+                saved: this.hasPendingMessages() ? false : true,
+                timeout: pendingOpsTimeout,
+                countBefore,
+                countAfter: this.pendingMessagesCount,
+            });
+            // There could still be pending ops. Check if summary should fail or continue.
+            const pendingMessagesFailResult = await this.shouldFailSummaryOnPendingOps(summaryNumberLogger, this.deltaManager.lastSequenceNumber, this.deltaManager.minimumSequenceNumber, finalAttempt, true /* beforeSummaryGeneration */);
+            if (pendingMessagesFailResult !== undefined) {
+                return pendingMessagesFailResult;
+            }
+        }
         const shouldPauseInboundSignal = this.mc.config.getBoolean("Fluid.ContainerRuntime.SubmitSummary.disableInboundSignalPause") !== true;
         let summaryRefSeqNum;
         try {
@@ -1607,7 +1759,6 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.summarizerNode.startSummary(summaryRefSeqNum, summaryNumberLogger);
             // Helper function to check whether we should still continue between each async step.
             const checkContinue = () => {
-                var _a;
                 // Do not check for loss of connectivity directly! Instead leave it up to
                 // RunWhileConnectedCoordinator to control policy in a single place.
                 // This will allow easier change of design if we chose to. For example, we may chose to allow
@@ -1630,7 +1781,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                         error: `lastSequenceNumber changed before uploading to storage. ${this.deltaManager.lastSequenceNumber} !== ${summaryRefSeqNum}`,
                     };
                 }
-                assert(summaryRefSeqNum === ((_a = this.deltaManager.lastMessage) === null || _a === void 0 ? void 0 : _a.sequenceNumber), 0x395 /* it's one and the same thing */);
+                assert(summaryRefSeqNum === this.deltaManager.lastMessage?.sequenceNumber, 0x395 /* it's one and the same thing */);
                 if (lastAck !== this.summaryCollection.latestAck) {
                     return {
                         continue: false,
@@ -1669,6 +1820,25 @@ export class ContainerRuntime extends TypedEventEmitter {
                     error,
                 };
             }
+            // If validateSummaryBeforeUpload is true, validate that the summary generated is correct before uploading.
+            if (this.validateSummaryBeforeUpload) {
+                // Validate that the summaries generated by summarize nodes is correct.
+                const validateResult = this.summarizerNode.validateSummary();
+                if (!validateResult.success) {
+                    const { success, ...loggingProps } = validateResult;
+                    const error = new RetriableSummaryError(validateResult.reason, validateResult.retryAfterSeconds, { ...loggingProps });
+                    return {
+                        stage: "base",
+                        referenceSequenceNumber: summaryRefSeqNum,
+                        minimumSequenceNumber,
+                        error,
+                    };
+                }
+                const pendingMessagesFailResult = await this.shouldFailSummaryOnPendingOps(summaryNumberLogger, summaryRefSeqNum, minimumSequenceNumber, finalAttempt, false /* beforeSummaryGeneration */);
+                if (pendingMessagesFailResult !== undefined) {
+                    return pendingMessagesFailResult;
+                }
+            }
             const { summary: summaryTree, stats: partialStats } = summarizeResult;
             // Now that we have generated the summary, update the message at last summary to the last message processed.
             this.messageAtLastSummary = this.deltaManager.lastMessage;
@@ -1681,7 +1851,15 @@ export class ContainerRuntime extends TypedEventEmitter {
             const gcSummaryTreeStats = summaryTree.tree[gcTreeKey]
                 ? calculateStats(summaryTree.tree[gcTreeKey])
                 : undefined;
-            const summaryStats = Object.assign({ dataStoreCount: this.dataStores.size, summarizedDataStoreCount: this.dataStores.size - handleCount, gcStateUpdatedDataStoreCount: this.garbageCollector.updatedDSCountSinceLastSummary, gcBlobNodeCount: gcSummaryTreeStats === null || gcSummaryTreeStats === void 0 ? void 0 : gcSummaryTreeStats.blobNodeCount, gcTotalBlobsSize: gcSummaryTreeStats === null || gcSummaryTreeStats === void 0 ? void 0 : gcSummaryTreeStats.totalBlobSize, summaryNumber }, partialStats);
+            const summaryStats = {
+                dataStoreCount: this.dataStores.size,
+                summarizedDataStoreCount: this.dataStores.size - handleCount,
+                gcStateUpdatedDataStoreCount: this.garbageCollector.updatedDSCountSinceLastSummary,
+                gcBlobNodeCount: gcSummaryTreeStats?.blobNodeCount,
+                gcTotalBlobsSize: gcSummaryTreeStats?.totalBlobSize,
+                summaryNumber,
+                ...partialStats,
+            };
             const generateSummaryData = {
                 referenceSequenceNumber: summaryRefSeqNum,
                 minimumSequenceNumber,
@@ -1692,7 +1870,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             };
             continueResult = checkContinue();
             if (!continueResult.continue) {
-                return Object.assign(Object.assign({ stage: "generate" }, generateSummaryData), { error: continueResult.error });
+                return { stage: "generate", ...generateSummaryData, error: continueResult.error };
             }
             // It may happen that the lastAck it not correct due to missing summaryAck in case of single commit
             // summary. So if the previous summarizer closes just after submitting the summary and before
@@ -1700,7 +1878,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             // latestSnapshotVersionId from storage and it does not match with the lastAck ackHandle, then use
             // the one fetched from storage as parent as that is the latest.
             let summaryContext;
-            if ((lastAck === null || lastAck === void 0 ? void 0 : lastAck.summaryAck.contents.handle) !== latestSnapshotVersionId &&
+            if (lastAck?.summaryAck.contents.handle !== latestSnapshotVersionId &&
                 latestSnapshotVersionId !== undefined) {
                 summaryContext = {
                     proposalHandle: undefined,
@@ -1711,7 +1889,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             else if (lastAck === undefined) {
                 summaryContext = {
                     proposalHandle: undefined,
-                    ackHandle: (_a = this.context.getLoadedFromVersion()) === null || _a === void 0 ? void 0 : _a.id,
+                    ackHandle: this.loadedFromVersionId,
                     referenceSequenceNumber: summaryRefSeqNum,
                 };
             }
@@ -1727,7 +1905,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 handle = await this.storage.uploadSummaryWithContext(summarizeResult.summary, summaryContext);
             }
             catch (error) {
-                return Object.assign(Object.assign({ stage: "generate" }, generateSummaryData), { error });
+                return { stage: "generate", ...generateSummaryData, error };
             }
             const parent = summaryContext.ackHandle;
             const summaryMessage = {
@@ -1737,27 +1915,42 @@ export class ContainerRuntime extends TypedEventEmitter {
                 message,
                 parents: parent ? [parent] : [],
             };
-            const uploadData = Object.assign(Object.assign({}, generateSummaryData), { handle, uploadDuration: trace.trace().duration });
+            const uploadData = {
+                ...generateSummaryData,
+                handle,
+                uploadDuration: trace.trace().duration,
+            };
             continueResult = checkContinue();
             if (!continueResult.continue) {
-                return Object.assign(Object.assign({ stage: "upload" }, uploadData), { error: continueResult.error });
+                return { stage: "upload", ...uploadData, error: continueResult.error };
             }
             let clientSequenceNumber;
             try {
                 clientSequenceNumber = this.submitSummaryMessage(summaryMessage, summaryRefSeqNum);
             }
             catch (error) {
-                return Object.assign(Object.assign({ stage: "upload" }, uploadData), { error });
+                return { stage: "upload", ...uploadData, error };
+            }
+            const submitData = {
+                stage: "submit",
+                ...uploadData,
+                clientSequenceNumber,
+                submitOpDuration: trace.trace().duration,
+            };
+            try {
+                // If validateSummaryBeforeUpload is false, the summary should be validated in this step.
+                this.summarizerNode.completeSummary(handle, !this.validateSummaryBeforeUpload /* validate */);
+            }
+            catch (error) {
+                return { stage: "upload", ...uploadData, error };
             }
-            const submitData = Object.assign(Object.assign({ stage: "submit" }, uploadData), { clientSequenceNumber, submitOpDuration: trace.trace().duration });
-            this.summarizerNode.completeSummary(handle);
             return submitData;
         }
         finally {
             // Cleanup wip summary in case of failure
             this.summarizerNode.clearSummary();
             // ! This needs to happen before we resume inbound queues to ensure heuristics are tracked correctly
-            (_c = (_b = this._summarizer) === null || _b === void 0 ? void 0 : _b.recordSummaryAttempt) === null || _c === void 0 ? void 0 : _c.call(_b, summaryRefSeqNum);
+            this._summarizer?.recordSummaryAttempt?.(summaryRefSeqNum);
             // Restart the delta manager
             this.deltaManager.inbound.resume();
             if (shouldPauseInboundSignal) {
@@ -1765,8 +1958,55 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
         }
     }
+    /**
+     * This helper is called during summarization. If there are pending ops, it will return a failed summarize result
+     * (IBaseSummarizeResult) unless this is the final summarize attempt and SkipFailingIncorrectSummary option is set.
+     * @param logger - The logger to be used for sending telemetry.
+     * @param referenceSequenceNumber - The reference sequence number of the summary attempt.
+     * @param minimumSequenceNumber - The minimum sequence number of the summary attempt.
+     * @param finalAttempt - Whether this is the final summary attempt.
+     * @param beforeSummaryGeneration - Whether this is called before summary generation or after.
+     * @returns failed summarize result (IBaseSummarizeResult) if summary should be failed, undefined otherwise.
+     */
+    async shouldFailSummaryOnPendingOps(logger, referenceSequenceNumber, minimumSequenceNumber, finalAttempt, beforeSummaryGeneration) {
+        if (!this.hasPendingMessages()) {
+            return;
+        }
+        // If "SkipFailingIncorrectSummary" option is true, don't fail the summary in the last attempt.
+        // This is a fallback to make progress in documents where there are consistently pending ops in
+        // the summarizer.
+        if (finalAttempt &&
+            this.mc.config.getBoolean("Fluid.Summarizer.SkipFailingIncorrectSummary")) {
+            const error = DataProcessingError.create("Pending ops during summarization", "submitSummary", undefined, { pendingMessages: this.pendingMessagesCount });
+            logger.sendErrorEvent({
+                eventName: "SkipFailingIncorrectSummary",
+                referenceSequenceNumber,
+                minimumSequenceNumber,
+                beforeGenerate: beforeSummaryGeneration,
+            }, error);
+        }
+        else {
+            // The retry delay when there are pending ops can be overridden via config so that we can adjust it
+            // based on telemetry while we decide on a stable number.
+            const retryDelayMs = this.mc.config.getNumber("Fluid.Summarizer.PendingOpsRetryDelayMs") ??
+                defaultPendingOpsRetryDelayMs;
+            const error = new RetriableSummaryError("PendingOpsWhileSummarizing", retryDelayMs / 1000, {
+                count: this.pendingMessagesCount,
+                beforeGenerate: beforeSummaryGeneration,
+            });
+            return {
+                stage: "base",
+                referenceSequenceNumber,
+                minimumSequenceNumber,
+                error,
+            };
+        }
+    }
+    get pendingMessagesCount() {
+        return this.pendingStateManager.pendingMessagesCount + this.outbox.messageCount;
+    }
     hasPendingMessages() {
-        return this.pendingStateManager.hasPendingMessages() || !this.outbox.isEmpty;
+        return this.pendingMessagesCount !== 0;
     }
     updateDocumentDirtyState(dirty) {
         if (this.attachState !== AttachState.Attached) {
@@ -1782,7 +2022,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.dirtyContainer = dirty;
         if (this.emitDirtyDocumentEvent) {
             this.emit(dirty ? "dirty" : "saved");
-            this.context.updateDirtyContainerState(dirty);
         }
     }
     submitDataStoreOp(id, contents, localOpMetadata = undefined) {
@@ -1790,21 +2029,20 @@ export class ContainerRuntime extends TypedEventEmitter {
             address: id,
             contents,
         };
-        this.submit(ContainerMessageType.FluidDataStoreOp, envelope, localOpMetadata);
+        this.submit({ type: ContainerMessageType.FluidDataStoreOp, contents: envelope }, localOpMetadata);
     }
     submitDataStoreAliasOp(contents, localOpMetadata) {
         const aliasMessage = contents;
         if (!isDataStoreAliasMessage(aliasMessage)) {
             throw new UsageError("malformedDataStoreAliasMessage");
         }
-        this.submit(ContainerMessageType.Alias, contents, localOpMetadata);
+        this.submit({ type: ContainerMessageType.Alias, contents }, localOpMetadata);
     }
-    async uploadBlob(blob) {
+    async uploadBlob(blob, signal) {
         this.verifyNotClosed();
-        return this.blobManager.createBlob(blob);
+        return this.blobManager.createBlob(blob, signal);
     }
     maybeSubmitIdAllocationOp(type) {
-        var _a, _b;
         if (type !== ContainerMessageType.IdAllocation) {
             let idAllocationBatchMessage;
             let idRange;
@@ -1812,7 +2050,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 assert(this.idCompressor !== undefined, 0x67d /* IdCompressor should be defined if enabled */);
                 idRange = this.idCompressor.takeNextCreationRange();
                 // Don't include the idRange if there weren't any Ids allocated
-                idRange = ((_a = idRange === null || idRange === void 0 ? void 0 : idRange.ids) === null || _a === void 0 ? void 0 : _a.first) !== undefined ? idRange : undefined;
+                idRange = idRange?.ids !== undefined ? idRange : undefined;
             }
             if (idRange !== undefined) {
                 const idAllocationMessage = {
@@ -1823,7 +2061,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                     contents: JSON.stringify(idAllocationMessage),
                     referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
                     metadata: undefined,
-                    localOpMetadata: (_b = this.idCompressor) === null || _b === void 0 ? void 0 : _b.serialize(true),
+                    localOpMetadata: this.idCompressor?.serialize(true),
                     type: ContainerMessageType.IdAllocation,
                 };
             }
@@ -1832,20 +2070,21 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
         }
     }
-    submit(type, contents, localOpMetadata = undefined, metadata = undefined) {
+    submit(containerRuntimeMessage, localOpMetadata = undefined, metadata = undefined) {
         this.verifyNotClosed();
         this.verifyCanSubmitOps();
         // There should be no ops in detached container state!
         assert(this.attachState !== AttachState.Detached, 0x132 /* "sending ops in detached container" */);
-        const serializedContent = JSON.stringify({ type, contents });
+        const serializedContent = JSON.stringify(containerRuntimeMessage);
         // Note that the real (non-proxy) delta manager is used here to get the readonly info. This is because
         // container runtime's ability to submit ops depend on the actual readonly state of the delta manager.
         if (this.innerDeltaManager.readOnlyInfo.readonly) {
-            this.logger.sendTelemetryEvent({
+            this.mc.logger.sendTelemetryEvent({
                 eventName: "SubmitOpInReadonly",
                 connected: this.connected,
             });
         }
+        const type = containerRuntimeMessage.type;
         const message = {
             contents: serializedContent,
             type,
@@ -1884,6 +2123,10 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.disableAttachReorder !== true) {
                 this.outbox.submitAttach(message);
             }
+            else if (type === ContainerMessageType.BlobAttach) {
+                // BlobAttach ops must have their metadata visible and cannot be grouped (see opGroupingManager.ts)
+                this.outbox.submitBlobAttach(message);
+            }
             else {
                 this.outbox.submit(message);
             }
@@ -1898,7 +2141,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.closeFn(error);
             throw error;
         }
-        if (this.isContainerMessageDirtyable(type, contents)) {
+        if (this.isContainerMessageDirtyable(containerRuntimeMessage)) {
             this.updateDocumentDirtyState(true);
         }
     }
@@ -1941,9 +2184,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         // System message should not be sent in the middle of the batch.
         assert(this.outbox.isEmpty, 0x3d4 /* System op in the middle of a batch */);
         // back-compat: ADO #1385: Make this call unconditional in the future
-        return this.context.submitSummaryFn !== undefined
-            ? this.context.submitSummaryFn(contents, referenceSequenceNumber)
-            : this.context.submitFn(MessageType.Summarize, contents, false);
+        return this.submitSummaryFn !== undefined
+            ? this.submitSummaryFn(contents, referenceSequenceNumber)
+            : this.submitFn(MessageType.Summarize, contents, false);
     }
     /**
      * Throw an error if the runtime is closed.  Methods that are expected to potentially
@@ -1960,7 +2203,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             if (this.opReentryCallsToReport > 0) {
                 this.mc.logger.sendTelemetryEvent({ eventName: "OpReentry" }, 
                 // We need to capture the call stack in order to inspect the source of this usage pattern
-                new UsageError(errorMessage));
+                getLongStack(() => new UsageError(errorMessage)));
                 this.opReentryCallsToReport--;
             }
             // Creating ops while processing ops can lead
@@ -1980,34 +2223,43 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
         }
     }
-    reSubmit(content, localOpMetadata, opMetadata) {
+    reSubmitBatch(batch) {
+        this.orderSequentially(() => {
+            for (const message of batch) {
+                this.reSubmit(message);
+            }
+        });
+        this.flush();
+    }
+    reSubmit(message) {
         // Need to parse from string for back-compat
-        const { contents, type } = this.parseOpContent(content);
-        this.reSubmitCore(type, contents, localOpMetadata, opMetadata);
+        const containerRuntimeMessage = this.parseOpContent(message.content);
+        this.reSubmitCore(containerRuntimeMessage, message.localOpMetadata, message.opMetadata);
     }
     /**
      * Finds the right store and asks it to resubmit the message. This typically happens when we
      * reconnect and there are pending messages.
-     * @param content - The content of the original message.
+     * @param message - The original ContainerRuntimeMessage.
      * @param localOpMetadata - The local metadata associated with the original message.
      */
-    reSubmitCore(type, content, localOpMetadata, opMetadata) {
-        switch (type) {
+    reSubmitCore(message, localOpMetadata, opMetadata) {
+        const contents = message.contents;
+        switch (message.type) {
             case ContainerMessageType.FluidDataStoreOp:
                 // For Operations, call resubmitDataStoreOp which will find the right store
                 // and trigger resubmission on it.
-                this.dataStores.resubmitDataStoreOp(content, localOpMetadata);
+                this.dataStores.resubmitDataStoreOp(contents, localOpMetadata);
                 break;
             case ContainerMessageType.Attach:
             case ContainerMessageType.Alias:
-                this.submit(type, content, localOpMetadata);
+                this.submit(message, localOpMetadata);
                 break;
             case ContainerMessageType.IdAllocation:
                 // Remove the stashedState from the op if it's a stashed op
-                if (content.stashedState !== undefined) {
-                    delete content.stashedState;
+                if (contents.stashedState !== undefined) {
+                    delete contents.stashedState;
                 }
-                this.submit(type, content, localOpMetadata);
+                this.submit(message, localOpMetadata);
                 break;
             case ContainerMessageType.ChunkedOp:
                 throw new Error(`chunkedOp not expected here`);
@@ -2015,10 +2267,29 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.blobManager.reSubmit(opMetadata);
                 break;
             case ContainerMessageType.Rejoin:
-                this.submit(type, content);
+                this.submit(message);
                 break;
-            default:
-                unreachableCase(type, `Unknown ContainerMessageType: ${type}`);
+            default: {
+                // This case should be very rare - it would imply an op was stashed from a
+                // future version of runtime code and now is being applied on an older version
+                const compatBehavior = message.compatDetails?.behavior;
+                if (compatBehaviorAllowsMessageType(message.type, compatBehavior)) {
+                    this.logger.sendTelemetryEvent({
+                        eventName: "resubmitUnrecognizedMessageTypeAllowed",
+                        messageDetails: { type: message.type, compatBehavior },
+                    });
+                }
+                else {
+                    const error = DataProcessingError.create("Resubmitting runtime message of unknown type", "reSubmitCore", undefined /* sequencedMessage */, {
+                        messageDetails: JSON.stringify({
+                            type: message.type,
+                            compatBehavior,
+                        }),
+                    });
+                    this.closeFn(error);
+                    throw error;
+                }
+            }
         }
     }
     rollback(content, localOpMetadata) {
@@ -2031,6 +2302,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.dataStores.rollbackDataStoreOp(contents, localOpMetadata);
                 break;
             default:
+                // Don't check message.compatDetails because this is for rolling back a local op so the type will be known
                 throw new Error(`Can't rollback ${type}`);
         }
     }
@@ -2048,29 +2320,22 @@ export class ContainerRuntime extends TypedEventEmitter {
     /** Implementation of ISummarizerInternalsProvider.refreshLatestSummaryAck */
     async refreshLatestSummaryAck(options) {
         const { proposalHandle, ackHandle, summaryRefSeq, summaryLogger } = options;
+        // proposalHandle is always passed from RunningSummarizer.
+        assert(proposalHandle !== undefined, 0x766 /* proposalHandle should be available */);
         const readAndParseBlob = async (id) => readAndParse(this.storage, id);
-        // The call to fetch the snapshot is very expensive and not always needed.
-        // It should only be done by the summarizerNode, if required.
-        // When fetching from storage we will always get the latest version and do not use the ackHandle.
-        const fetchLatestSnapshot = async () => {
-            let fetchResult = await this.fetchLatestSnapshotFromStorage(summaryLogger, {
+        const result = await this.summarizerNode.refreshLatestSummary(proposalHandle, summaryRefSeq);
+        /**
+         * When refreshing a summary ack, this check indicates a new ack of a summary that is newer than the
+         * current summary that is tracked, but this summarizer runtime did not produce/track that summary. Thus
+         * it needs to refresh its state. Today refresh is done by fetching the latest snapshot to update the cache
+         * and then close as the current main client is likely to be re-elected as the parent summarizer again.
+         */
+        if (!result.isSummaryTracked && result.isSummaryNewer) {
+            const fetchResult = await this.fetchSnapshotFromStorage(summaryLogger, {
                 eventName: "RefreshLatestSummaryAckFetch",
                 ackHandle,
                 targetSequenceNumber: summaryRefSeq,
-            }, readAndParseBlob);
-            /**
-             * back-compat - Older loaders and drivers (pre 2.0.0-internal.1.4) don't have fetchSource as a param in the
-             * getVersions API. So, they will not fetch the latest snapshot from network in the previous fetch call. For
-             * these scenarios, fetch the snapshot corresponding to the ack handle to have the same behavior before the
-             * change that started fetching latest snapshot always.
-             */
-            if (fetchResult.latestSnapshotRefSeq < summaryRefSeq) {
-                fetchResult = await this.fetchSnapshotFromStorage(summaryLogger, {
-                    eventName: "RefreshLatestSummaryAckFetchBackCompat",
-                    ackHandle,
-                    targetSequenceNumber: summaryRefSeq,
-                }, readAndParseBlob, ackHandle);
-            }
+            }, readAndParseBlob, null);
             /**
              * If the fetched snapshot is older than the one for which the ack was received, close the container.
              * This should never happen because an ack should be sent after the latest summary is updated in the server.
@@ -2087,20 +2352,14 @@ export class ContainerRuntime extends TypedEventEmitter {
                     summaryRefSeq,
                     fetchedSnapshotRefSeq: fetchResult.latestSnapshotRefSeq,
                 });
-                this.closeFn(error);
+                this.disposeFn(error);
                 throw error;
             }
-            // In case we had to retrieve the latest snapshot and it is different than summaryRefSeq,
-            // wait for the delta manager to catch up before refreshing the latest Summary.
-            await this.waitForDeltaManagerToCatchup(fetchResult.latestSnapshotRefSeq, summaryLogger);
-            return {
-                snapshotTree: fetchResult.snapshotTree,
-                snapshotRefSeq: fetchResult.latestSnapshotRefSeq,
-            };
-        };
-        const result = await this.summarizerNode.refreshLatestSummary(proposalHandle, summaryRefSeq, fetchLatestSnapshot, readAndParseBlob, summaryLogger);
+            await this.closeStaleSummarizer("RefreshLatestSummaryAckFetch");
+            return;
+        }
         // Notify the garbage collector so it can update its latest summary state.
-        await this.garbageCollector.refreshLatestSummary(proposalHandle, result, readAndParseBlob);
+        await this.garbageCollector.refreshLatestSummary(result);
     }
     /**
      * Fetches the latest snapshot from storage and uses it to refresh SummarizerNode's
@@ -2110,24 +2369,31 @@ export class ContainerRuntime extends TypedEventEmitter {
      */
     async refreshLatestSummaryAckFromServer(summaryLogger) {
         const readAndParseBlob = async (id) => readAndParse(this.storage, id);
-        const { snapshotTree, versionId, latestSnapshotRefSeq } = await this.fetchLatestSnapshotFromStorage(summaryLogger, {
+        const { versionId, latestSnapshotRefSeq } = await this.fetchSnapshotFromStorage(summaryLogger, {
             eventName: "RefreshLatestSummaryFromServerFetch",
-        }, readAndParseBlob);
-        const fetchLatestSnapshot = {
-            snapshotTree,
-            snapshotRefSeq: latestSnapshotRefSeq,
-        };
-        const result = await this.summarizerNode.refreshLatestSummary(undefined /* proposalHandle */, latestSnapshotRefSeq, async () => fetchLatestSnapshot, readAndParseBlob, summaryLogger);
-        // Notify the garbage collector so it can update its latest summary state.
-        await this.garbageCollector.refreshLatestSummary(undefined /* proposalHandle */, result, readAndParseBlob);
+        }, readAndParseBlob, null);
+        await this.closeStaleSummarizer("RefreshLatestSummaryFromServerFetch");
         return { latestSnapshotRefSeq, latestSnapshotVersionId: versionId };
     }
-    async fetchLatestSnapshotFromStorage(logger, event, readAndParseBlob) {
-        return this.fetchSnapshotFromStorage(logger, event, readAndParseBlob, null /* latest */);
+    async closeStaleSummarizer(codePath) {
+        this.mc.logger.sendTelemetryEvent({
+            eventName: "ClosingSummarizerOnSummaryStale",
+            codePath,
+            message: "Stopping fetch from storage",
+            closeSummarizerDelayMs: this.closeSummarizerDelayMs,
+        }, new GenericError("Restarting summarizer instead of refreshing"));
+        // Delay before restarting summarizer to prevent the summarizer from restarting too frequently.
+        await delay(this.closeSummarizerDelayMs);
+        this._summarizer?.stop("latestSummaryStateStale");
+        this.disposeFn();
     }
+    /**
+     * Downloads snapshot from storage with the given versionId or latest if versionId is null.
+     * By default, it also closes the container after downloading the snapshot. However, this may be
+     * overridden via options.
+     */
     async fetchSnapshotFromStorage(logger, event, readAndParseBlob, versionId) {
-        var _a;
-        const snapshotResults = await PerformanceEvent.timedExecAsync(logger, event, async (perfEvent) => {
+        return PerformanceEvent.timedExecAsync(logger, event, async (perfEvent) => {
             const stats = {};
             const trace = Trace.start();
             const versions = await this.storage.getVersions(versionId, 1, "refreshLatestSummaryAckFromServer", versionId === null ? FetchSource.noCache : undefined);
@@ -2146,33 +2412,65 @@ export class ContainerRuntime extends TypedEventEmitter {
                 latestSnapshotRefSeq,
             };
         });
-        // We choose to close the summarizer after the snapshot cache is updated to avoid
-        // situations which the main client (which is likely to be re-elected as the leader again)
-        // loads the summarizer from cache.
-        if (this.summaryStateUpdateMethod === "restart") {
-            const error = new GenericError("Restarting summarizer instead of refreshing");
-            this.mc.logger.sendTelemetryEvent(Object.assign(Object.assign({}, event), { eventName: "ClosingSummarizerOnSummaryStale", codePath: event.eventName, message: "Stopping fetch from storage", versionId: versionId != null ? versionId : undefined, closeSummarizerDelayMs: this.closeSummarizerDelayMs }), error);
-            // Delay 10 seconds before restarting summarizer to prevent the summarizer from restarting too frequently.
-            await delay(this.closeSummarizerDelayMs);
-            (_a = this._summarizer) === null || _a === void 0 ? void 0 : _a.stop("latestSummaryStateStale");
-            this.closeFn();
-            throw error;
-        }
-        return snapshotResults;
     }
     notifyAttaching() { } // do nothing (deprecated method)
-    getPendingLocalState() {
-        if (this._orderSequentiallyCalls !== 0) {
-            throw new UsageError("can't get state during orderSequentially");
+    async getPendingLocalState(props) {
+        return PerformanceEvent.timedExecAsync(this.mc.logger, {
+            eventName: "getPendingLocalState",
+            notifyImminentClosure: props?.notifyImminentClosure,
+        }, async (event) => {
+            this.verifyNotClosed();
+            const waitBlobsToAttach = props?.notifyImminentClosure;
+            if (this._orderSequentiallyCalls !== 0) {
+                throw new UsageError("can't get state during orderSequentially");
+            }
+            const pendingAttachmentBlobs = await this.blobManager.getPendingBlobs(waitBlobsToAttach);
+            const pending = this.pendingStateManager.getLocalState();
+            if (!pendingAttachmentBlobs && !this.hasPendingMessages()) {
+                return; // no pending state to save
+            }
+            // Flush pending batch.
+            // getPendingLocalState() is only exposed through Container.closeAndGetPendingLocalState(), so it's safe
+            // to close current batch.
+            this.flush();
+            const pendingState = {
+                pending,
+                pendingAttachmentBlobs,
+            };
+            event.end({
+                attachmentBlobsSize: Object.keys(pendingAttachmentBlobs ?? {}).length,
+                pendingOpsSize: pending?.pendingStates.length,
+            });
+            return pendingState;
+        });
+    }
+    summarizeOnDemand(options) {
+        if (this.isSummarizerClient) {
+            return this.summarizer.summarizeOnDemand(options);
+        }
+        else if (this.summaryManager !== undefined) {
+            return this.summaryManager.summarizeOnDemand(options);
+        }
+        else {
+            // If we're not the summarizer, and we don't have a summaryManager, we expect that
+            // disableSummaries is turned on. We are throwing instead of returning a failure here,
+            // because it is a misuse of the API rather than an expected failure.
+            throw new UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
+        }
+    }
+    enqueueSummarize(options) {
+        if (this.isSummarizerClient) {
+            return this.summarizer.enqueueSummarize(options);
+        }
+        else if (this.summaryManager !== undefined) {
+            return this.summaryManager.enqueueSummarize(options);
+        }
+        else {
+            // If we're not the summarizer, and we don't have a summaryManager, we expect that
+            // generateSummaries is turned off. We are throwing instead of returning a failure here,
+            // because it is a misuse of the API rather than an expected failure.
+            throw new UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
         }
-        // Flush pending batch.
-        // getPendingLocalState() is only exposed through Container.closeAndGetPendingLocalState(), so it's safe
-        // to close current batch.
-        this.flush();
-        return {
-            pending: this.pendingStateManager.getLocalState(),
-            pendingAttachmentBlobs: this.blobManager.getPendingBlobs(),
-        };
     }
     /**
      * * Forms a function that will request a Summarizer.