@fluidframework/container-runtime 2.0.0-dev.3.1.0.125672 → 2.0.0-dev.4.2.0.153917

package/dist/containerRuntime.js

@@ -10,29 +10,22 @@ const container_utils_1 = require("@fluidframework/container-utils");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const runtime_definitions_1 = require("@fluidframework/runtime-definitions");
 const runtime_utils_1 = require("@fluidframework/runtime-utils");
-const garbage_collector_1 = require("@fluidframework/garbage-collector");
 const uuid_1 = require("uuid");
 const containerHandleContext_1 = require("./containerHandleContext");
 const dataStoreRegistry_1 = require("./dataStoreRegistry");
-const summarizer_1 = require("./summarizer");
-const summaryManager_1 = require("./summaryManager");
 const connectionTelemetry_1 = require("./connectionTelemetry");
 const pendingStateManager_1 = require("./pendingStateManager");
 const packageVersion_1 = require("./packageVersion");
 const blobManager_1 = require("./blobManager");
 const dataStores_1 = require("./dataStores");
-const summaryFormat_1 = require("./summaryFormat");
-const summaryCollection_1 = require("./summaryCollection");
-const orderedClientElection_1 = require("./orderedClientElection");
-const summarizerClientElection_1 = require("./summarizerClientElection");
+const summary_1 = require("./summary");
 const throttler_1 = require("./throttler");
-const runWhileConnectedCoordinator_1 = require("./runWhileConnectedCoordinator");
-const garbageCollection_1 = require("./garbageCollection");
+const gc_1 = require("./gc");
 const dataStore_1 = require("./dataStore");
 const batchTracker_1 = require("./batchTracker");
-const serializedSnapshotStorage_1 = require("./serializedSnapshotStorage");
 const scheduleManager_1 = require("./scheduleManager");
 const opLifecycle_1 = require("./opLifecycle");
+const deltaManagerSummarizerProxy_1 = require("./deltaManagerSummarizerProxy");
 var ContainerMessageType;
 (function (ContainerMessageType) {
     // An op to be delivered to store
@@ -55,7 +48,7 @@ exports.DefaultSummaryConfiguration = {
     maxTime: 60 * 1000,
     maxOps: 100,
     minOpsForLastSummaryAttempt: 10,
-    maxAckWaitTime: 10 * 60 * 1000,
+    maxAckWaitTime: 3 * 60 * 1000,
     maxOpsSinceLastSummary: 7000,
     initialSummarizerDelayMs: 5 * 1000,
     nonRuntimeOpWeight: 0.1,
@@ -69,11 +62,6 @@ var RuntimeHeaders;
 (function (RuntimeHeaders) {
     /** True to wait for a data store to be created and loaded before returning it. */
     RuntimeHeaders["wait"] = "wait";
-    /**
-     * True if the request is from an external app. Used for GC to handle scenarios where a data store
-     * is deleted and requested via an external app.
-     */
-    RuntimeHeaders["externalRequest"] = "externalRequest";
     /** True if the request is coming from an IFluidHandle. */
     RuntimeHeaders["viaHandle"] = "viaHandle";
 })(RuntimeHeaders = exports.RuntimeHeaders || (exports.RuntimeHeaders = {}));
@@ -84,7 +72,6 @@ exports.TombstoneResponseHeaderKey = "isTombstoned";
 /** Default values for Runtime Headers */
 exports.defaultRuntimeHeaderData = {
     wait: true,
-    externalRequest: false,
     viaHandle: false,
     allowTombstone: false,
 };
@@ -101,7 +88,13 @@ const defaultFlushMode = runtime_definitions_1.FlushMode.TurnBased;
 // We can't estimate it fully, as we
 // - do not know what properties relay service will add
 // - we do not stringify final op, thus we do not know how much escaping will be added.
-const defaultMaxBatchSizeInBytes = 950 * 1024;
+const defaultMaxBatchSizeInBytes = 700 * 1024;
+const defaultCompressionConfig = {
+    // Batches with content size exceeding this value will be compressed
+    minimumBatchSizeInBytes: 614400,
+    compressionAlgorithm: CompressionAlgorithms.lz4,
+};
+const defaultChunkSizeInBytes = 204800;
 /**
  * @deprecated - use ContainerRuntimeMessage instead
  */
@@ -150,8 +143,8 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
     /**
      * @internal
      */
-    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, requestHandler, summaryConfiguration) {
-        var _a, _b, _c, _d, _e, _f;
+    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, requestHandler, summaryConfiguration, initializeEntryPoint) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         if (summaryConfiguration === void 0) { summaryConfiguration = Object.assign(Object.assign({}, exports.DefaultSummaryConfiguration), (_a = runtimeOptions.summaryOptions) === null || _a === void 0 ? void 0 : _a.summaryConfigOverrides); }
         super();
         this.context = context;
@@ -164,8 +157,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         this.summaryConfiguration = summaryConfiguration;
         this.defaultMaxConsecutiveReconnects = 7;
         this._orderSequentiallyCalls = 0;
-        this.flushMicroTaskExists = false;
-        this.savedOps = [];
+        this.flushTaskExists = false;
         this.consecutiveReconnects = 0;
         this.ensureNoDataModelChangesCalls = 0;
         /**
@@ -185,7 +177,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             trackingSignalSequenceNumber: undefined,
         };
         this.summarizeOnDemand = (...args) => {
-            if (this.clientDetails.type === summarizerClientElection_1.summarizerClientType) {
+            if (this.clientDetails.type === summary_1.summarizerClientType) {
                 return this.summarizer.summarizeOnDemand(...args);
             }
             else if (this.summaryManager !== undefined) {
@@ -199,7 +191,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             }
         };
         this.enqueueSummarize = (...args) => {
-            if (this.clientDetails.type === summarizerClientElection_1.summarizerClientType) {
+            if (this.clientDetails.type === summary_1.summarizerClientType) {
                 return this.summarizer.enqueueSummarize(...args);
             }
             else if (this.summaryManager !== undefined) {
@@ -212,6 +204,8 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 throw new container_utils_1.UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
             }
         };
+        this.innerDeltaManager = context.deltaManager;
+        this.deltaManager = new deltaManagerSummarizerProxy_1.DeltaManagerSummarizerProxy(context.deltaManager);
         let loadSummaryNumber;
         // Get the container creation metadata. For new container, we initialize these. For existing containers,
         // get the values from the metadata blob.
@@ -234,29 +228,47 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         this.nextSummaryNumber = loadSummaryNumber + 1;
         this.messageAtLastSummary = metadata === null || metadata === void 0 ? void 0 : metadata.message;
         this._connected = this.context.connected;
+        this.gcTombstoneEnforcementAllowed = (0, gc_1.shouldAllowGcTombstoneEnforcement)((_c = metadata === null || metadata === void 0 ? void 0 : metadata.gcFeatureMatrix) === null || _c === void 0 ? void 0 : _c.tombstoneGeneration /* persisted */, this.runtimeOptions.gcOptions[gc_1.gcTombstoneGenerationOptionName] /* current */);
         this.mc = (0, telemetry_utils_1.loggerToMonitoringContext)(telemetry_utils_1.ChildLogger.create(this.logger, "ContainerRuntime"));
-        const opSplitter = new opLifecycle_1.OpSplitter(chunks, this.context.submitBatchFn, this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableCompressionChunking") === true
-            ? Number.POSITIVE_INFINITY
-            : runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger);
-        this.remoteMessageProcessor = new opLifecycle_1.RemoteMessageProcessor(opSplitter, new opLifecycle_1.OpDecompressor());
+        this.mc.logger.sendTelemetryEvent({
+            eventName: "GCFeatureMatrix",
+            metadataValue: JSON.stringify(metadata === null || metadata === void 0 ? void 0 : metadata.gcFeatureMatrix),
+            inputs: JSON.stringify({
+                gcOptions_gcTombstoneGeneration: this.runtimeOptions.gcOptions[gc_1.gcTombstoneGenerationOptionName],
+            }),
+        });
+        this.telemetryDocumentId = (_d = metadata === null || metadata === void 0 ? void 0 : metadata.telemetryDocumentId) !== null && _d !== void 0 ? _d : (0, uuid_1.v4)();
+        this.disableAttachReorder = this.mc.config.getBoolean("Fluid.ContainerRuntime.disableAttachOpReorder");
+        const disableChunking = this.mc.config.getBoolean("Fluid.ContainerRuntime.CompressionChunkingDisabled");
+        const opGroupingManager = new opLifecycle_1.OpGroupingManager(this.groupedBatchingEnabled);
+        const opSplitter = new opLifecycle_1.OpSplitter(chunks, this.context.submitBatchFn, disableChunking === true ? Number.POSITIVE_INFINITY : runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger);
+        this.remoteMessageProcessor = new opLifecycle_1.RemoteMessageProcessor(opSplitter, new opLifecycle_1.OpDecompressor(this.mc.logger), opGroupingManager);
         this.handleContext = new containerHandleContext_1.ContainerFluidHandleContext("", this);
         if (this.summaryConfiguration.state === "enabled") {
             this.validateSummaryHeuristicConfiguration(this.summaryConfiguration);
         }
+        const disableOpReentryCheck = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableOpReentryCheck");
         this.enableOpReentryCheck =
             runtimeOptions.enableOpReentryCheck === true &&
                 // Allow for a break-glass config to override the options
-                this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableOpReentryCheck") !== true;
+                disableOpReentryCheck !== true;
         this.summariesDisabled = this.isSummariesDisabled();
         this.heuristicsDisabled = this.isHeuristicsDisabled();
         this.maxOpsSinceLastSummary = this.getMaxOpsSinceLastSummary();
         this.initialSummarizerDelayMs = this.getInitialSummarizerDelayMs();
         this.maxConsecutiveReconnects =
-            (_c = this.mc.config.getNumber(maxConsecutiveReconnectsKey)) !== null && _c !== void 0 ? _c : this.defaultMaxConsecutiveReconnects;
-        this._flushMode = runtimeOptions.flushMode;
+            (_e = this.mc.config.getNumber(maxConsecutiveReconnectsKey)) !== null && _e !== void 0 ? _e : this.defaultMaxConsecutiveReconnects;
+        if (runtimeOptions.flushMode === runtime_definitions_1.FlushModeExperimental.Async &&
+            ((_f = context.supportedFeatures) === null || _f === void 0 ? void 0 : _f.get("referenceSequenceNumbers")) !== true) {
+            // The loader does not support reference sequence numbers, falling back on FlushMode.TurnBased
+            this.mc.logger.sendErrorEvent({ eventName: "FlushModeFallback" });
+            this._flushMode = runtime_definitions_1.FlushMode.TurnBased;
+        }
+        else {
+            this._flushMode = runtimeOptions.flushMode;
+        }
         const pendingRuntimeState = context.pendingLocalState;
-        const baseSnapshot = (_d = pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.baseSnapshot) !== null && _d !== void 0 ? _d : context.baseSnapshot;
-        const maxSnapshotCacheDurationMs = (_f = (_e = this._storage) === null || _e === void 0 ? void 0 : _e.policies) === null || _f === void 0 ? void 0 : _f.maximumCacheDurationMs;
+        const maxSnapshotCacheDurationMs = (_h = (_g = this._storage) === null || _g === void 0 ? void 0 : _g.policies) === null || _h === void 0 ? void 0 : _h.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,
@@ -264,29 +276,31 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             // As long as the actual value is less than 5 days, the assumptions GC makes here are valid.
             throw new container_utils_1.UsageError("Driver's maximumCacheDurationMs policy cannot exceed 5 days");
         }
-        this.garbageCollector = garbageCollection_1.GarbageCollector.create({
+        this.garbageCollector = gc_1.GarbageCollector.create({
             runtime: this,
             gcOptions: this.runtimeOptions.gcOptions,
-            baseSnapshot,
+            baseSnapshot: context.baseSnapshot,
             baseLogger: this.mc.logger,
             existing,
             metadata,
             createContainerMetadata: this.createContainerMetadata,
-            isSummarizerClient: this.context.clientDetails.type === summarizerClientElection_1.summarizerClientType,
+            isSummarizerClient: this.context.clientDetails.type === summary_1.summarizerClientType,
             getNodePackagePath: async (nodePath) => this.getGCNodePackagePath(nodePath),
             getLastSummaryTimestampMs: () => { var _a; return (_a = this.messageAtLastSummary) === null || _a === void 0 ? void 0 : _a.timestamp; },
             readAndParseBlob: async (id) => (0, driver_utils_1.readAndParse)(this.storage, id),
             getContainerDiagnosticId: () => this.context.id,
-            activeConnection: () => this.deltaManager.active,
+            // 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 = (0, runtime_utils_1.createRootSummarizerNodeWithGC)(telemetry_utils_1.ChildLogger.create(this.logger, "SummarizerNode"), 
+        this.summarizerNode = (0, summary_1.createRootSummarizerNodeWithGC)(telemetry_utils_1.ChildLogger.create(this.logger, "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
-        baseSnapshot ? loadedFromSequenceNumber : undefined, {
+        context.baseSnapshot ? 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,
@@ -300,18 +314,24 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         async (fullGC) => this.getGCDataInternal(fullGC), 
         // Function to get the GC details from the base snapshot we loaded from.
         async () => this.garbageCollector.getBaseGCDetails());
-        if (baseSnapshot) {
-            this.summarizerNode.updateBaseSummaryState(baseSnapshot);
+        if (context.baseSnapshot) {
+            this.summarizerNode.updateBaseSummaryState(context.baseSnapshot);
         }
-        this.dataStores = new dataStores_1.DataStores((0, dataStores_1.getSummaryForDatastores)(baseSnapshot, metadata), this, (attachMsg) => this.submit(ContainerMessageType.Attach, attachMsg), (id, createParam) => (summarizeInternal, getGCDataFn, getBaseGCDetailsFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn, getBaseGCDetailsFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, async () => this.garbageCollector.getBaseGCDetails(), (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), new Map(dataStoreAliasMap));
+        this.dataStores = new dataStores_1.DataStores((0, dataStores_1.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.blobManager = new blobManager_1.BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (localId, blobId) => {
             if (!this.disposed) {
-                this.submit(ContainerMessageType.BlobAttach, undefined, undefined, {
-                    localId,
-                    blobId,
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                Promise.resolve().then(() => {
+                    // Blob attaches need to be in their own batch (grouped batching would hide metadata)
+                    this.flush();
+                    this.submit(ContainerMessageType.BlobAttach, undefined, undefined, {
+                        localId,
+                        blobId,
+                    });
+                    this.flush();
                 });
             }
-        }, (blobPath) => this.garbageCollector.nodeUpdated(blobPath, "Loaded"), (fromPath, toPath) => this.garbageCollector.addedOutboundReference(fromPath, toPath), (blobPath) => this.garbageCollector.isNodeDeleted(blobPath), this, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pendingAttachmentBlobs, () => this.getCurrentReferenceTimestampMs());
+        }, (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_1.ScheduleManager(context.deltaManager, this, () => this.clientId, telemetry_utils_1.ChildLogger.create(this.logger, "ScheduleManager"));
         this.pendingStateManager = new pendingStateManager_1.PendingStateManager({
             applyStashedOp: this.applyStashedOp.bind(this),
@@ -322,12 +342,14 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             rollback: this.rollback.bind(this),
             orderSequentially: this.orderSequentially.bind(this),
         }, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pending);
-        const compressionOptions = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableCompression") === true
+        const disableCompression = this.mc.config.getBoolean("Fluid.ContainerRuntime.CompressionDisabled");
+        const compressionOptions = disableCompression === true
             ? {
                 minimumBatchSizeInBytes: Number.POSITIVE_INFINITY,
                 compressionAlgorithm: CompressionAlgorithms.lz4,
             }
             : runtimeOptions.compressionOptions;
+        const disablePartialFlush = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisablePartialFlush");
         this.outbox = new opLifecycle_1.Outbox({
             shouldSend: () => this.canSendOps(),
             pendingStateManager: this.pendingStateManager,
@@ -337,14 +359,15 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             config: {
                 compressionOptions,
                 maxBatchSizeInBytes: runtimeOptions.maxBatchSizeInBytes,
-                enableOpReentryCheck: this.enableOpReentryCheck,
+                disablePartialFlush: disablePartialFlush === true,
             },
             logger: this.mc.logger,
+            groupingManager: opGroupingManager,
         });
         this.context.quorum.on("removeMember", (clientId) => {
             this.remoteMessageProcessor.clearPartialMessagesFor(clientId);
         });
-        this.summaryCollection = new summaryCollection_1.SummaryCollection(this.deltaManager, this.logger);
+        this.summaryCollection = new summary_1.SummaryCollection(this.deltaManager, this.logger);
         this.dirtyContainer =
             this.context.attachState !== container_definitions_1.AttachState.Attached ||
                 this.pendingStateManager.hasPendingMessages();
@@ -354,13 +377,16 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         }
         else {
             const orderedClientLogger = telemetry_utils_1.ChildLogger.create(this.logger, "OrderedClientElection");
-            const orderedClientCollection = new orderedClientElection_1.OrderedClientCollection(orderedClientLogger, this.context.deltaManager, this.context.quorum);
-            const orderedClientElectionForSummarizer = new orderedClientElection_1.OrderedClientElection(orderedClientLogger, orderedClientCollection, electedSummarizerData !== null && electedSummarizerData !== void 0 ? electedSummarizerData : this.context.deltaManager.lastSequenceNumber, summarizerClientElection_1.SummarizerClientElection.isClientEligible);
-            this.summarizerClientElection = new summarizerClientElection_1.SummarizerClientElection(orderedClientLogger, this.summaryCollection, orderedClientElectionForSummarizer, this.maxOpsSinceLastSummary);
-            if (this.context.clientDetails.type === summarizerClientElection_1.summarizerClientType) {
-                this._summarizer = new summarizer_1.Summarizer("/_summarizer", this /* ISummarizerRuntime */, () => this.summaryConfiguration, this /* ISummarizerInternalsProvider */, this.handleContext, this.summaryCollection, async (runtime) => runWhileConnectedCoordinator_1.RunWhileConnectedCoordinator.create(runtime));
+            const orderedClientCollection = new summary_1.OrderedClientCollection(orderedClientLogger, this.context.deltaManager, this.context.quorum);
+            const orderedClientElectionForSummarizer = new summary_1.OrderedClientElection(orderedClientLogger, orderedClientCollection, electedSummarizerData !== null && electedSummarizerData !== void 0 ? electedSummarizerData : this.context.deltaManager.lastSequenceNumber, summary_1.SummarizerClientElection.isClientEligible);
+            this.summarizerClientElection = new summary_1.SummarizerClientElection(orderedClientLogger, this.summaryCollection, orderedClientElectionForSummarizer, this.maxOpsSinceLastSummary);
+            if (this.context.clientDetails.type === summary_1.summarizerClientType) {
+                this._summarizer = new summary_1.Summarizer(this /* ISummarizerRuntime */, () => this.summaryConfiguration, this /* ISummarizerInternalsProvider */, this.handleContext, this.summaryCollection, async (runtime) => summary_1.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_1.SummarizerClientElection.clientDetailsPermitElection(this.context.clientDetails)) {
+            else if (summary_1.SummarizerClientElection.clientDetailsPermitElection(this.context.clientDetails)) {
                 // Only create a SummaryManager and SummarizerClientElection
                 // if summaries are enabled and we are not the summarizer client.
                 const defaultAction = () => {
@@ -380,7 +406,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 };
                 this.summaryCollection.on("default", defaultAction);
                 // Create the SummaryManager and mark the initial state
-                this.summaryManager = new summaryManager_1.SummaryManager(this.summarizerClientElection, this, // IConnectedState
+                this.summaryManager = new summary_1.SummaryManager(this.summarizerClientElection, this, // IConnectedState
                 this.summaryCollection, this.logger, this.formRequestSummarizerFn(this.context.loader), new throttler_1.Throttler(60 * 1000, // 60 sec delay window
                 30 * 1000, // 30 sec max delay
                 // throttling function increases exponentially (0ms, 40ms, 80ms, 160ms, etc)
@@ -393,7 +419,8 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         this.deltaManager.on("readonly", (readonly) => {
             // we accumulate ops while being in read-only state.
             // once user gets write permissions and we have active connection, flush all pending ops.
-            (0, common_utils_1.assert)(readonly === this.deltaManager.readOnlyInfo.readonly, 0x124 /* "inconsistent readonly property/event state" */);
+            // Note that the inner (non-proxy) delta manager is needed here to get the readonly information.
+            (0, common_utils_1.assert)(readonly === this.innerDeltaManager.readOnlyInfo.readonly, 0x124 /* "inconsistent readonly property/event state" */);
             // We need to be very careful with when we (re)send pending ops, to ensure that we only send ops
             // when we either never send an op, or attempted to send it but we know for sure it was not
             // sequenced by server and will never be sequenced (i.e. was lost)
@@ -411,9 +438,22 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         });
         // 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 }));
+        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({
+                disableCompression,
+                disableOpReentryCheck,
+                disableChunking,
+                disableAttachReorder: this.disableAttachReorder,
+                disablePartialFlush,
+            }), telemetryDocumentId: this.telemetryDocumentId, groupedBatchingEnabled: this.groupedBatchingEnabled }));
         (0, connectionTelemetry_1.ReportOpPerfTelemetry)(this.context.clientId, this.deltaManager, this.logger);
         (0, batchTracker_1.BindBatchTracker)(this, this.logger);
+        this.entryPoint = new common_utils_1.LazyPromise(async () => {
+            if (this.context.clientDetails.type === summary_1.summarizerClientType) {
+                (0, common_utils_1.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);
+        });
     }
     get IContainerRuntime() {
         return this;
@@ -451,17 +491,20 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
      * Load the stores from a snapshot and returns the runtime.
      * @param params - An object housing the runtime properties:
      * - context - Context of the container.
-     * - registryEntries - Mapping to the stores.
-     * - existing - When loading from an existing snapshot
-     * - requestHandler - Request handlers for the container runtime
+     * - registryEntries - Mapping from data store types to their corresponding factories.
+     * - existing - Pass 'true' if loading from an existing snapshot.
+     * - requestHandler - (optional) Request handler for the request() method of the container runtime.
+     * Only relevant for back-compat while we remove the request() method and move fully to entryPoint as the main pattern.
      * - runtimeOptions - Additional options to be passed to the runtime
      * - containerScope - runtime services provided with context
      * - containerRuntimeCtor - Constructor to use to create the ContainerRuntime instance.
      * This allows mixin classes to leverage this method to define their own async initializer.
+     * - initializeEntryPoint - Promise that resolves to an object which will act as entryPoint for the Container.
+     * 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;
-        const { context, registryEntries, existing, requestHandler, runtimeOptions = {}, containerScope = {}, containerRuntimeCtor = ContainerRuntime, } = params;
+        const { context, registryEntries, existing, requestHandler, runtimeOptions = {}, containerScope = {}, containerRuntimeCtor = ContainerRuntime, initializeEntryPoint, } = params;
         // 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;
@@ -471,45 +514,36 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 runtimeVersion: packageVersion_1.pkgVersion,
             },
         });
-        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, enableOfflineLoad = false, compressionOptions = {
-            minimumBatchSizeInBytes: Number.POSITIVE_INFINITY,
-            compressionAlgorithm: CompressionAlgorithms.lz4,
-        }, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, chunkSizeInBytes = Number.POSITIVE_INFINITY, enableOpReentryCheck = false, } = runtimeOptions;
-        const pendingRuntimeState = context.pendingLocalState;
-        const baseSnapshot = (_b = pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.baseSnapshot) !== null && _b !== void 0 ? _b : context.baseSnapshot;
-        const storage = !pendingRuntimeState
-            ? context.storage
-            : new serializedSnapshotStorage_1.SerializedSnapshotStorage(() => {
-                return context.storage;
-            }, pendingRuntimeState.snapshotBlobs);
+        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, compressionOptions = defaultCompressionConfig, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, chunkSizeInBytes = defaultChunkSizeInBytes, enableOpReentryCheck = false, enableGroupedBatching = false, } = runtimeOptions;
         const registry = new dataStoreRegistry_1.FluidDataStoreRegistry(registryEntries);
         const tryFetchBlob = async (blobName) => {
-            const blobId = baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.blobs[blobName];
-            if (baseSnapshot && blobId) {
+            var _a;
+            const blobId = (_a = context.baseSnapshot) === null || _a === void 0 ? void 0 : _a.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.
-                (0, common_utils_1.assert)(storage !== undefined, 0x1f5 /* "Attached state should have storage" */);
-                return (0, driver_utils_1.readAndParse)(storage, blobId);
+                (0, common_utils_1.assert)(context.storage !== undefined, 0x1f5 /* "Attached state should have storage" */);
+                return (0, driver_utils_1.readAndParse)(context.storage, blobId);
             }
         };
         const [chunks, metadata, electedSummarizerData, aliases] = await Promise.all([
-            tryFetchBlob(summaryFormat_1.chunksBlobName),
-            tryFetchBlob(summaryFormat_1.metadataBlobName),
-            tryFetchBlob(summaryFormat_1.electedSummarizerBlobName),
-            tryFetchBlob(summaryFormat_1.aliasBlobName),
+            tryFetchBlob(summary_1.chunksBlobName),
+            tryFetchBlob(summary_1.metadataBlobName),
+            tryFetchBlob(summary_1.electedSummarizerBlobName),
+            tryFetchBlob(summary_1.aliasBlobName),
         ]);
         const loadExisting = existing === true || context.existing === true;
         // read snapshot blobs needed for BlobManager to load
-        const blobManagerSnapshot = await blobManager_1.BlobManager.load(baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[summaryFormat_1.blobsTreeName], async (id) => {
+        const blobManagerSnapshot = await blobManager_1.BlobManager.load((_b = context.baseSnapshot) === null || _b === void 0 ? void 0 : _b.trees[summary_1.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.
-            (0, common_utils_1.assert)(storage !== undefined, 0x256 /* "storage undefined in attached container" */);
-            return (0, driver_utils_1.readAndParse)(storage, id);
+            (0, common_utils_1.assert)(context.storage !== undefined, 0x256 /* "storage undefined in attached container" */);
+            return (0, driver_utils_1.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;
         // When we load with pending state, we reuse an old snapshot so we don't expect these numbers to match
-        if (!pendingRuntimeState && runtimeSequenceNumber !== undefined) {
+        if (!context.pendingLocalState && runtimeSequenceNumber !== undefined) {
             const protocolSequenceNumber = context.deltaManager.initialSequenceNumber;
             // Unless bypass is explicitly set, then take action when sequence numbers mismatch.
             if (loadSequenceNumberVerification !== "bypass" &&
@@ -533,17 +567,16 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             gcOptions,
             loadSequenceNumberVerification,
             flushMode,
-            enableOfflineLoad,
             compressionOptions,
             maxBatchSizeInBytes,
             chunkSizeInBytes,
             enableOpReentryCheck,
-        }, containerScope, logger, loadExisting, blobManagerSnapshot, storage, requestHandler);
-        if (pendingRuntimeState) {
-            await runtime.processSavedOps(pendingRuntimeState);
-            // delete these once runtime has seen them to save space
-            pendingRuntimeState.savedOps = [];
-        }
+            enableGroupedBatching,
+        }, containerScope, logger, loadExisting, blobManagerSnapshot, context.storage, requestHandler, undefined, // summaryConfiguration
+        initializeEntryPoint);
+        // 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);
         // Initialize the base state of the runtime before it's returned.
         await runtime.initializeBaseState();
         return runtime;
@@ -557,9 +590,6 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
     get clientDetails() {
         return this.context.clientDetails;
     }
-    get deltaManager() {
-        return this.context.deltaManager;
-    }
     get storage() {
         return this._storage;
     }
@@ -652,7 +682,6 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
      * Initializes the state from the base snapshot this container runtime loaded from.
      */
     async initializeBaseState() {
-        await this.initializeBaseSnapshotBlobs();
         await this.garbageCollector.initializeBaseState();
     }
     dispose(error) {
@@ -677,16 +706,6 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         this.emit("dispose");
         this.removeAllListeners();
     }
-    get IFluidTokenProvider() {
-        var _a;
-        if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.intelligence) {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            return {
-                intelligence: this.options.intelligence,
-            };
-        }
-        return undefined;
-    }
     /**
      * Notifies this object about the request made to the container.
      * @param request - Request made to the handler.
@@ -749,12 +768,18 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             return (0, runtime_utils_1.exceptionToResponse)(error);
         }
     }
+    /**
+     * {@inheritDoc @fluidframework/container-definitions#IRuntime.getEntryPoint}
+     */
+    async getEntryPoint() {
+        return this.entryPoint;
+    }
     internalId(maybeAlias) {
         var _a;
         return (_a = this.dataStores.aliases.get(maybeAlias)) !== null && _a !== void 0 ? _a : maybeAlias;
     }
     async getDataStoreFromRequest(id, request) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         const headerData = {};
         if (typeof ((_a = request.headers) === null || _a === void 0 ? void 0 : _a[RuntimeHeaders.wait]) === "boolean") {
             headerData.wait = request.headers[RuntimeHeaders.wait];
@@ -768,27 +793,10 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         await this.dataStores.waitIfPendingAlias(id);
         const internalId = this.internalId(id);
         const dataStoreContext = await this.dataStores.getDataStore(internalId, headerData);
-        /**
-         * If GC should run and this an external app request with "externalRequest" header, we need to return
-         * an error if the data store being requested is marked as unreferenced as per the data store's base
-         * GC data.
-         *
-         * This is a workaround to handle scenarios where a data store shared with an external app is deleted
-         * and marked as unreferenced by GC. Returning an error will fail to load the data store for the app.
-         */
-        if (((_d = request.headers) === null || _d === void 0 ? void 0 : _d[RuntimeHeaders.externalRequest]) &&
-            this.garbageCollector.shouldRunGC) {
-            // The data store is referenced if used routes in the base summary has a route to self.
-            // Older documents may not have used routes in the summary. They are considered referenced.
-            const usedRoutes = (await dataStoreContext.getBaseGCDetails()).usedRoutes;
-            if (!(usedRoutes === undefined || usedRoutes.includes("") || usedRoutes.includes("/"))) {
-                throw (0, runtime_utils_1.responseToException)((0, runtime_utils_1.create404Response)(request), request);
-            }
-        }
         const dataStoreChannel = await dataStoreContext.realize();
         // 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 = (0, garbage_collector_1.trimLeadingAndTrailingSlashes)(request.url.split("?")[0]);
+        const urlWithoutQuery = (0, gc_1.trimLeadingAndTrailingSlashes)(request.url.split("?")[0]);
         this.garbageCollector.nodeUpdated(`/${urlWithoutQuery}`, "Loaded", undefined /* timestampMs */, dataStoreContext.packagePath, request === null || request === void 0 ? void 0 : request.headers);
         return dataStoreChannel;
     }
@@ -800,29 +808,29 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             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 = (0, summaryFormat_1.extractSummaryMetadataMessage)(this.deltaManager.lastMessage)) !== null && _a !== void 0 ? _a : this.messageAtLastSummary });
-        (0, runtime_utils_1.addBlobToSummary)(summaryTree, summaryFormat_1.metadataBlobName, JSON.stringify(metadata));
+            message: (_a = (0, summary_1.extractSummaryMetadataMessage)(this.deltaManager.lastMessage)) !== null && _a !== void 0 ? _a : this.messageAtLastSummary, telemetryDocumentId: this.telemetryDocumentId });
+        (0, runtime_utils_1.addBlobToSummary)(summaryTree, summary_1.metadataBlobName, JSON.stringify(metadata));
     }
     addContainerStateToSummary(summaryTree, fullTree, trackState, telemetryContext) {
         var _a;
         this.addMetadataToSummary(summaryTree);
         if (this.remoteMessageProcessor.partialMessages.size > 0) {
             const content = JSON.stringify([...this.remoteMessageProcessor.partialMessages]);
-            (0, runtime_utils_1.addBlobToSummary)(summaryTree, summaryFormat_1.chunksBlobName, content);
+            (0, runtime_utils_1.addBlobToSummary)(summaryTree, summary_1.chunksBlobName, content);
         }
         const dataStoreAliases = this.dataStores.aliases;
         if (dataStoreAliases.size > 0) {
-            (0, runtime_utils_1.addBlobToSummary)(summaryTree, summaryFormat_1.aliasBlobName, JSON.stringify([...dataStoreAliases]));
+            (0, runtime_utils_1.addBlobToSummary)(summaryTree, summary_1.aliasBlobName, JSON.stringify([...dataStoreAliases]));
         }
         if (this.summarizerClientElection) {
             const electedSummarizerContent = JSON.stringify((_a = this.summarizerClientElection) === null || _a === void 0 ? void 0 : _a.serialize());
-            (0, runtime_utils_1.addBlobToSummary)(summaryTree, summaryFormat_1.electedSummarizerBlobName, electedSummarizerContent);
+            (0, runtime_utils_1.addBlobToSummary)(summaryTree, summary_1.electedSummarizerBlobName, electedSummarizerContent);
         }
         const blobManagerSummary = this.blobManager.summarize();
         // Some storage (like git) doesn't allow empty tree, so we can omit it.
         // and the blob manager can handle the tree not existing when loading
         if (Object.keys(blobManagerSummary.summary.tree).length > 0) {
-            (0, runtime_utils_1.addTreeToSummary)(summaryTree, summaryFormat_1.blobsTreeName, blobManagerSummary);
+            (0, runtime_utils_1.addTreeToSummary)(summaryTree, summary_1.blobsTreeName, blobManagerSummary);
         }
         const gcSummary = this.garbageCollector.summarize(fullTree, trackState, telemetryContext);
         if (gcSummary !== undefined) {
@@ -916,7 +924,8 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         // 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
-        const connecting = connected && !this._connected && !this.deltaManager.readOnlyInfo.readonly;
+        // 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) {
             (0, common_utils_1.assert)(!this.delayConnectClientId, 0x392 /* Connect event delay must be canceled before subsequent connect event */);
             (0, common_utils_1.assert)(!!clientId, 0x393 /* Must have clientId when connecting */);
@@ -966,19 +975,23 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         this.garbageCollector.setConnectionState(connected, clientId);
         (0, telemetry_utils_1.raiseConnectedEvent)(this.mc.logger, this, connected, clientId);
     }
+    async notifyOpReplay(message) {
+        await this.pendingStateManager.applyStashedOpsAt(message.sequenceNumber);
+    }
     process(messageArg, local) {
-        var _a;
         this.verifyNotClosed();
-        if ((_a = this.mc.config.getBoolean("enableOfflineLoad")) !== null && _a !== void 0 ? _a : this.runtimeOptions.enableOfflineLoad) {
-            this.savedOps.push(messageArg);
-        }
         // Whether or not the message is actually a runtime message.
         // It may be a legacy runtime message (ie already unpacked and ContainerMessageType)
         // or something different, like a system message.
         const runtimeMessage = messageArg.type === protocol_definitions_1.MessageType.Operation;
         // Do shallow copy of message, as the processing flow will modify it.
         const messageCopy = Object.assign({}, messageArg);
-        const message = this.remoteMessageProcessor.process(messageCopy);
+        for (const message of this.remoteMessageProcessor.process(messageCopy)) {
+            this.processCore(message, local, runtimeMessage);
+        }
+    }
+    processCore(message, local, runtimeMessage) {
+        var _a;
         // 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.
@@ -1011,10 +1024,21 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 case ContainerMessageType.Rejoin:
                     break;
                 default:
-                    (0, common_utils_1.assert)(!runtimeMessage, 0x3ce /* Runtime message of unknown type */);
+                    if (runtimeMessage) {
+                        const error = container_utils_1.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;
+                    }
             }
-            // For back-compat, notify only about runtime messages for now.
-            if (runtimeMessage) {
+            if (runtimeMessage || this.groupedBatchingEnabled) {
                 this.emit("op", message, runtimeMessage);
             }
             this.scheduleManager.afterOpProcessing(undefined, message);
@@ -1072,7 +1096,10 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             }
             else if (envelope.clientSignalSequenceNumber ===
                 this._perfSignalData.trackingSignalSequenceNumber) {
-                this.sendSignalTelemetryEvent(envelope.clientSignalSequenceNumber);
+                // only logging for the first connection and the trackingSignalSequenceNUmber.
+                if (this.consecutiveReconnects === 0) {
+                    this.sendSignalTelemetryEvent(envelope.clientSignalSequenceNumber);
+                }
                 this._perfSignalData.trackingSignalSequenceNumber = undefined;
             }
         }
@@ -1169,13 +1196,15 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             .realize();
     }
     canSendOps() {
-        return this.connected && !this.deltaManager.readOnlyInfo.readonly;
+        // Note that the real (non-proxy) delta manager is needed here to get the readonly info. This is because
+        // container runtime's ability to send ops depend on the actual readonly state of the delta manager.
+        return this.connected && !this.innerDeltaManager.readOnlyInfo.readonly;
     }
     /**
      * Are we in the middle of batching ops together?
      */
     currentlyBatching() {
-        return this.flushMode === runtime_definitions_1.FlushMode.TurnBased || this._orderSequentiallyCalls !== 0;
+        return this.flushMode !== runtime_definitions_1.FlushMode.Immediate || this._orderSequentiallyCalls !== 0;
     }
     getQuorum() {
         return this.context.quorum;
@@ -1264,7 +1293,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         }
         const summarizeResult = this.dataStores.createSummary(telemetryContext);
         // Wrap data store summaries in .channels subtree.
-        (0, summaryFormat_1.wrapSummaryInChannelsTree)(summarizeResult);
+        (0, summary_1.wrapSummaryInChannelsTree)(summarizeResult);
         this.addContainerStateToSummary(summarizeResult, true /* fullTree */, false /* trackState */, telemetryContext);
         return summarizeResult.summary;
     }
@@ -1280,7 +1309,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
     async summarizeInternal(fullTree, trackState, telemetryContext) {
         const summarizeResult = await this.dataStores.summarize(fullTree, trackState, telemetryContext);
         // Wrap data store summaries in .channels subtree.
-        (0, summaryFormat_1.wrapSummaryInChannelsTree)(summarizeResult);
+        (0, summary_1.wrapSummaryInChannelsTree)(summarizeResult);
         const pathPartsForChildren = [runtime_definitions_1.channelsTreeName];
         this.addContainerStateToSummary(summarizeResult, fullTree, trackState, telemetryContext);
         return Object.assign(Object.assign({}, summarizeResult), { id: "", pathPartsForChildren });
@@ -1291,11 +1320,19 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
     async summarize(options) {
         this.verifyNotClosed();
         const { fullTree = false, trackState = true, summaryLogger = this.mc.logger, runGC = this.garbageCollector.shouldRunGC, runSweep, fullGC, } = options;
+        const telemetryContext = new runtime_utils_1.TelemetryContext();
+        // Add the options that are used to generate this summary to the telemetry context.
+        telemetryContext.setMultiple("fluid_Summarize", "Options", {
+            fullTree,
+            trackState,
+            runGC,
+            fullGC,
+            runSweep,
+        });
         let gcStats;
         if (runGC) {
-            gcStats = await this.collectGarbage({ logger: summaryLogger, runSweep, fullGC });
+            gcStats = await this.collectGarbage({ logger: summaryLogger, runSweep, fullGC }, telemetryContext);
         }
-        const telemetryContext = new runtime_utils_1.TelemetryContext();
         const { stats, summary } = await this.summarizerNode.summarize(fullTree, trackState, telemetryContext);
         this.logger.sendTelemetryEvent({
             eventName: "SummarizeTelemetry",
@@ -1305,10 +1342,10 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         return { stats, summary, gcStats };
     }
     /**
-     * Implementation of IGarbageCollectionRuntime::updateStateBeforeGC.
      * Before GC runs, called by the garbage collector to update any pending GC state. This is mainly used to notify
      * the garbage collector of references detected since the last GC run. Most references are notified immediately
      * but there can be some for which async operation is required (such as detecting new root data stores).
+     * @see IGarbageCollectionRuntime.updateStateBeforeGC
      */
     async updateStateBeforeGC() {
         return this.dataStores.updateStateBeforeGC();
@@ -1317,12 +1354,12 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         return this.dataStores.getGCData(fullGC);
     }
     /**
-     * Implementation of IGarbageCollectionRuntime::getGCData.
      * Generates and returns the GC data for this container.
      * @param fullGC - true to bypass optimizations and force full generation of GC data.
+     * @see IGarbageCollectionRuntime.getGCData
      */
     async getGCData(fullGC) {
-        const builder = new garbage_collector_1.GCDataBuilder();
+        const builder = new runtime_utils_1.GCDataBuilder();
         const dsGCData = await this.summarizerNode.getGCData(fullGC);
         builder.addNodes(dsGCData.gcNodes);
         const blobsGCData = this.blobManager.getGCData(fullGC);
@@ -1330,9 +1367,9 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         return builder.getGCData();
     }
     /**
-     * Implementation of IGarbageCollectionRuntime::updateUsedRoutes.
      * After GC has run, called to notify this container's nodes of routes that are used in it.
      * @param usedRoutes - The routes that are used in all nodes in this Container.
+     * @see IGarbageCollectionRuntime.updateUsedRoutes
      */
     updateUsedRoutes(usedRoutes) {
         // Update our summarizer node's used routes. Updating used routes in summarizer node before
@@ -1351,6 +1388,22 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         this.blobManager.updateUnusedRoutes(blobManagerRoutes);
         this.dataStores.updateUnusedRoutes(dataStoreRoutes);
     }
+    /**
+     * @deprecated - Replaced by deleteSweepReadyNodes.
+     */
+    deleteUnusedNodes(unusedRoutes) {
+        throw new Error("deleteUnusedRoutes should not be called");
+    }
+    /**
+     * 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.
+     */
+    deleteSweepReadyNodes(sweepReadyRoutes) {
+        const { dataStoreRoutes, blobManagerRoutes } = this.getDataStoreAndBlobManagerRoutes(sweepReadyRoutes);
+        const deletedRoutes = this.dataStores.deleteSweepReadyNodes(dataStoreRoutes);
+        return deletedRoutes.concat(this.blobManager.deleteSweepReadyNodes(blobManagerRoutes));
+    }
     /**
      * This is called to update objects that are tombstones.
      * @param tombstonedRoutes - Data store and attachment blob routes that are tombstones in this Container.
@@ -1376,9 +1429,9 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
     getNodeType(nodePath) {
         var _a;
         if (this.isBlobPath(nodePath)) {
-            return garbageCollection_1.GCNodeType.Blob;
+            return gc_1.GCNodeType.Blob;
         }
-        return (_a = this.dataStores.getGCNodeType(nodePath)) !== null && _a !== void 0 ? _a : garbageCollection_1.GCNodeType.Other;
+        return (_a = this.dataStores.getGCNodeType(nodePath)) !== null && _a !== void 0 ? _a : gc_1.GCNodeType.Other;
     }
     /**
      * Called by GC to retrieve the package path of the node with the given path. The node should belong to a
@@ -1386,10 +1439,10 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
      */
     async getGCNodePackagePath(nodePath) {
         switch (this.getNodeType(nodePath)) {
-            case garbageCollection_1.GCNodeType.Blob:
+            case gc_1.GCNodeType.Blob:
                 return [blobManager_1.BlobManager.basePath];
-            case garbageCollection_1.GCNodeType.DataStore:
-            case garbageCollection_1.GCNodeType.SubDataStore:
+            case gc_1.GCNodeType.DataStore:
+            case gc_1.GCNodeType.SubDataStore:
                 return this.dataStores.getDataStorePackagePath(nodePath);
             default:
                 (0, common_utils_1.assert)(false, 0x2de /* "Package path requested for unsupported node type." */);
@@ -1428,8 +1481,8 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
      * Runs garbage collection and updates the reference / used state of the nodes in the container.
      * @returns the statistics of the garbage collection run; undefined if GC did not run.
      */
-    async collectGarbage(options) {
-        return this.garbageCollector.collectGarbage(options);
+    async collectGarbage(options, telemetryContext) {
+        return this.garbageCollector.collectGarbage(options, telemetryContext);
     }
     /**
      * Called when a new outbound reference is added to another node. This is used by garbage collection to identify
@@ -1450,7 +1503,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
      */
     async submitSummary(options) {
         var _a, _b;
-        const { fullTree, refreshLatestAck, summaryLogger } = options;
+        const { fullTree = 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;
@@ -1466,8 +1519,12 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             // We might need to catch up to the latest summary's reference sequence number before pausing.
             await this.waitForDeltaManagerToCatchup(latestSnapshotRefSeq, summaryNumberLogger);
         }
+        const shouldPauseInboundSignal = this.mc.config.getBoolean("Fluid.ContainerRuntime.SubmitSummary.disableInboundSignalPause") !== true;
         try {
             await this.deltaManager.inbound.pause();
+            if (shouldPauseInboundSignal) {
+                await this.deltaManager.inboundSignal.pause();
+            }
             const summaryRefSeqNum = this.deltaManager.lastSequenceNumber;
             const minimumSequenceNumber = this.deltaManager.minimumSequenceNumber;
             const message = `Summary @${summaryRefSeqNum}:${this.deltaManager.minimumSequenceNumber}`;
@@ -1523,7 +1580,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             const forcedFullTree = this.garbageCollector.summaryStateNeedsReset;
             try {
                 summarizeResult = await this.summarize({
-                    fullTree: fullTree !== null && fullTree !== void 0 ? fullTree : forcedFullTree,
+                    fullTree: fullTree || forcedFullTree,
                     trackState: true,
                     summaryLogger: summaryNumberLogger,
                     runGC: this.garbageCollector.shouldRunGC,
@@ -1612,7 +1669,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             }
             let clientSequenceNumber;
             try {
-                clientSequenceNumber = this.submitSummaryMessage(summaryMessage);
+                clientSequenceNumber = this.submitSummaryMessage(summaryMessage, summaryRefSeqNum);
             }
             catch (error) {
                 return Object.assign(Object.assign({ stage: "upload" }, uploadData), { error });
@@ -1626,6 +1683,9 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             this.summarizerNode.clearSummary();
             // Restart the delta manager
             this.deltaManager.inbound.resume();
+            if (shouldPauseInboundSignal) {
+                this.deltaManager.inboundSignal.resume();
+            }
         }
     }
     hasPendingMessages() {
@@ -1671,9 +1731,10 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         this.verifyCanSubmitOps();
         // There should be no ops in detached container state!
         (0, common_utils_1.assert)(this.attachState !== container_definitions_1.AttachState.Detached, 0x132 /* "sending ops in detached container" */);
-        const deserializedContent = { type, contents };
-        const serializedContent = JSON.stringify(deserializedContent);
-        if (this.deltaManager.readOnlyInfo.readonly) {
+        const serializedContent = JSON.stringify({ type, contents });
+        // 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({
                 eventName: "SubmitOpInReadonly",
                 connected: this.connected,
@@ -1681,7 +1742,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         }
         const message = {
             contents: serializedContent,
-            deserializedContent,
+            deserializedContent: JSON.parse(serializedContent),
             metadata,
             localOpMetadata,
             referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
@@ -1709,7 +1770,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             // optimization no longer makes sense (for example, batch compression may make it less appealing).
             if (this.currentlyBatching() &&
                 type === ContainerMessageType.Attach &&
-                this.mc.config.getBoolean("Fluid.ContainerRuntime.disableAttachOpReorder") !== true) {
+                this.disableAttachReorder !== true) {
                 this.outbox.submitAttach(message);
             }
             else {
@@ -1718,17 +1779,8 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             if (!this.currentlyBatching()) {
                 this.flush();
             }
-            else if (!this.flushMicroTaskExists) {
-                this.flushMicroTaskExists = true;
-                // Queue a microtask to detect the end of the turn and force a flush.
-                Promise.resolve()
-                    .then(() => {
-                    this.flushMicroTaskExists = false;
-                    this.flush();
-                })
-                    .catch((error) => {
-                    this.closeFn(error);
-                });
+            else {
+                this.scheduleFlush();
             }
         }
         catch (error) {
@@ -1739,14 +1791,47 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             this.updateDocumentDirtyState(true);
         }
     }
-    submitSummaryMessage(contents) {
+    scheduleFlush() {
+        if (this.flushTaskExists) {
+            return;
+        }
+        this.flushTaskExists = true;
+        const flush = () => {
+            this.flushTaskExists = false;
+            try {
+                this.flush();
+            }
+            catch (error) {
+                this.closeFn(error);
+            }
+        };
+        switch (this.flushMode) {
+            case runtime_definitions_1.FlushMode.TurnBased:
+                // When in TurnBased flush mode the runtime will buffer operations in the current turn and send them as a single
+                // batch at the end of the turn
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                Promise.resolve().then(flush);
+                break;
+            // FlushModeExperimental is experimental and not exposed directly in the runtime APIs
+            case runtime_definitions_1.FlushModeExperimental.Async:
+                // When in Async flush mode, the runtime will accumulate all operations across JS turns and send them as a single
+                // batch when all micro-tasks are complete.
+                // Compared to TurnBased, this flush mode will capture more ops into the same batch.
+                setTimeout(flush, 0);
+                break;
+            default:
+                (0, common_utils_1.assert)(this._orderSequentiallyCalls > 0, 0x587 /* Unreachable unless running under orderSequentially */);
+                break;
+        }
+    }
+    submitSummaryMessage(contents, referenceSequenceNumber) {
         this.verifyNotClosed();
         (0, common_utils_1.assert)(this.connected, 0x133 /* "Container disconnected when trying to submit system message" */);
         // System message should not be sent in the middle of the batch.
         (0, common_utils_1.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)
+            ? this.context.submitSummaryFn(contents, referenceSequenceNumber)
             : this.context.submitFn(protocol_definitions_1.MessageType.Summarize, contents, false);
     }
     /**
@@ -1842,14 +1927,12 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         // 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 snapshotTreeFetcher = async () => {
-            const fetchResult = await this.fetchLatestSnapshotFromStorage(summaryLogger, {
-                eventName: "RefreshLatestSummaryGetSnapshot",
+        const fetchLatestSnapshot = async () => {
+            let fetchResult = await this.fetchLatestSnapshotFromStorage(summaryLogger, {
+                eventName: "RefreshLatestSummaryAckFetch",
                 ackHandle,
-                summaryRefSeq,
-                fetchLatest: true,
-            });
-            const latestSnapshotRefSeq = await (0, runtime_utils_1.seqFromTree)(fetchResult.snapshotTree, readAndParseBlob);
+                targetSequenceNumber: summaryRefSeq,
+            }, readAndParseBlob);
             /**
              * 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.
@@ -1860,29 +1943,34 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
              * such cases, the file will be rolled back along with the ack and we will eventually reach a consistent
              * state.
              */
-            if (latestSnapshotRefSeq < summaryRefSeq) {
-                const error = container_utils_1.DataProcessingError.create("Fetched snapshot is older than the received ack", "RefreshLatestSummaryAck", undefined /* sequencedMessage */, {
+            if (fetchResult.latestSnapshotRefSeq < summaryRefSeq) {
+                /* before failing, let's try to retrieve the latest snapshot for that specific ackHandle */
+                fetchResult = await this.fetchSnapshotFromStorage(summaryLogger, {
+                    eventName: "RefreshLatestSummaryAckFetch",
                     ackHandle,
-                    summaryRefSeq,
-                    latestSnapshotRefSeq,
-                });
-                this.closeFn(error);
-                throw error;
+                    targetSequenceNumber: summaryRefSeq,
+                }, readAndParseBlob, ackHandle);
+                if (fetchResult.latestSnapshotRefSeq < summaryRefSeq) {
+                    const error = container_utils_1.DataProcessingError.create("Fetched snapshot is older than the received ack", "RefreshLatestSummaryAck", undefined /* sequencedMessage */, {
+                        ackHandle,
+                        summaryRefSeq,
+                        fetchedSnapshotRefSeq: fetchResult.latestSnapshotRefSeq,
+                    });
+                    this.closeFn(error);
+                    throw error;
+                }
             }
-            summaryLogger.sendTelemetryEvent({
-                eventName: "LatestSummaryRetrieved",
-                ackHandle,
-                lastSequenceNumber: latestSnapshotRefSeq,
-                targetSequenceNumber: summaryRefSeq,
-            });
             // 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(latestSnapshotRefSeq, summaryLogger);
-            return fetchResult.snapshotTree;
+            await this.waitForDeltaManagerToCatchup(fetchResult.latestSnapshotRefSeq, summaryLogger);
+            return {
+                snapshotTree: fetchResult.snapshotTree,
+                snapshotRefSeq: fetchResult.latestSnapshotRefSeq,
+            };
         };
-        const result = await this.summarizerNode.refreshLatestSummary(proposalHandle, summaryRefSeq, snapshotTreeFetcher, readAndParseBlob, summaryLogger);
+        const result = await this.summarizerNode.refreshLatestSummary(proposalHandle, summaryRefSeq, fetchLatestSnapshot, readAndParseBlob, summaryLogger);
         // Notify the garbage collector so it can update its latest summary state.
-        await this.garbageCollector.refreshLatestSummary(result, proposalHandle, summaryRefSeq, readAndParseBlob);
+        await this.garbageCollector.refreshLatestSummary(proposalHandle, result, readAndParseBlob);
     }
     /**
      * Fetches the latest snapshot from storage and uses it to refresh SummarizerNode's
@@ -1891,53 +1979,54 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
      * @returns downloaded snapshot's reference sequence number
      */
     async refreshLatestSummaryAckFromServer(summaryLogger) {
-        const { snapshotTree, versionId } = await this.fetchLatestSnapshotFromStorage(summaryLogger, {
-            eventName: "RefreshLatestSummaryGetSnapshot",
-            fetchLatest: true,
-        });
         const readAndParseBlob = async (id) => (0, driver_utils_1.readAndParse)(this.storage, id);
-        const latestSnapshotRefSeq = await (0, runtime_utils_1.seqFromTree)(snapshotTree, readAndParseBlob);
-        const result = await this.summarizerNode.refreshLatestSummary(undefined, latestSnapshotRefSeq, async () => snapshotTree, readAndParseBlob, summaryLogger);
+        const { snapshotTree, versionId, latestSnapshotRefSeq } = await this.fetchLatestSnapshotFromStorage(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(result, undefined, latestSnapshotRefSeq, readAndParseBlob);
+        await this.garbageCollector.refreshLatestSummary(undefined /* proposalHandle */, result, readAndParseBlob);
         return { latestSnapshotRefSeq, latestSnapshotVersionId: versionId };
     }
-    async fetchLatestSnapshotFromStorage(logger, event) {
+    async fetchLatestSnapshotFromStorage(logger, event, readAndParseBlob) {
+        return this.fetchSnapshotFromStorage(logger, event, readAndParseBlob, null /* latest */);
+    }
+    async fetchSnapshotFromStorage(logger, event, readAndParseBlob, versionId) {
+        var _a;
+        const recoveryMethod = this.mc.config.getString("Fluid.ContainerRuntime.Test.SummarizationRecoveryMethod");
+        if (recoveryMethod === "restart") {
+            const error = new container_utils_1.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 }), error);
+            (_a = this._summarizer) === null || _a === void 0 ? void 0 : _a.stop("latestSummaryStateStale");
+            this.closeFn();
+            throw error;
+        }
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(logger, event, async (perfEvent) => {
             const stats = {};
             const trace = common_utils_1.Trace.start();
-            const versions = await this.storage.getVersions(null, 1, "refreshLatestSummaryAckFromServer", driver_definitions_1.FetchSource.noCache);
+            const versions = await this.storage.getVersions(versionId, 1, "refreshLatestSummaryAckFromServer", versionId === null ? driver_definitions_1.FetchSource.noCache : undefined);
             (0, common_utils_1.assert)(!!versions && !!versions[0], 0x137 /* "Failed to get version from storage" */);
             stats.getVersionDuration = trace.trace().duration;
             const maybeSnapshot = await this.storage.getSnapshotTree(versions[0]);
             (0, common_utils_1.assert)(!!maybeSnapshot, 0x138 /* "Failed to get snapshot from storage" */);
             stats.getSnapshotDuration = trace.trace().duration;
+            const latestSnapshotRefSeq = await (0, runtime_utils_1.seqFromTree)(maybeSnapshot, readAndParseBlob);
+            stats.snapshotRefSeq = latestSnapshotRefSeq;
+            stats.snapshotVersion = versions[0].id;
             perfEvent.end(stats);
-            return { snapshotTree: maybeSnapshot, versionId: versions[0].id };
+            return {
+                snapshotTree: maybeSnapshot,
+                versionId: versions[0].id,
+                latestSnapshotRefSeq,
+            };
         });
     }
-    notifyAttaching(snapshot) {
-        var _a;
-        if ((_a = this.mc.config.getBoolean("enableOfflineLoad")) !== null && _a !== void 0 ? _a : this.runtimeOptions.enableOfflineLoad) {
-            this.baseSnapshotBlobs =
-                serializedSnapshotStorage_1.SerializedSnapshotStorage.serializeTreeWithBlobContents(snapshot);
-        }
-    }
-    async initializeBaseSnapshotBlobs() {
-        var _a;
-        if (!((_a = this.mc.config.getBoolean("enableOfflineLoad")) !== null && _a !== void 0 ? _a : this.runtimeOptions.enableOfflineLoad) ||
-            this.attachState !== container_definitions_1.AttachState.Attached ||
-            this.context.pendingLocalState) {
-            return;
-        }
-        (0, common_utils_1.assert)(!!this.context.baseSnapshot, 0x2e5 /* "Must have a base snapshot" */);
-        this.baseSnapshotBlobs = await serializedSnapshotStorage_1.SerializedSnapshotStorage.serializeTree(this.context.baseSnapshot, this.storage);
-    }
+    notifyAttaching() { } // do nothing (deprecated method)
     getPendingLocalState() {
-        var _a;
-        if (!((_a = this.mc.config.getBoolean("enableOfflineLoad")) !== null && _a !== void 0 ? _a : this.runtimeOptions.enableOfflineLoad)) {
-            throw new container_utils_1.UsageError("can't get state when offline load disabled");
-        }
         if (this._orderSequentiallyCalls !== 0) {
             throw new container_utils_1.UsageError("can't get state during orderSequentially");
         }
@@ -1945,24 +2034,9 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         // getPendingLocalState() is only exposed through Container.closeAndGetPendingLocalState(), so it's safe
         // to close current batch.
         this.flush();
-        const previousPendingState = this.context.pendingLocalState;
-        if (previousPendingState) {
-            return {
-                pending: this.pendingStateManager.getLocalState(),
-                pendingAttachmentBlobs: this.blobManager.getPendingBlobs(),
-                snapshotBlobs: previousPendingState.snapshotBlobs,
-                baseSnapshot: previousPendingState.baseSnapshot,
-                savedOps: this.savedOps,
-            };
-        }
-        (0, common_utils_1.assert)(!!this.context.baseSnapshot, 0x2e6 /* "Must have a base snapshot" */);
-        (0, common_utils_1.assert)(!!this.baseSnapshotBlobs, 0x2e7 /* "Must serialize base snapshot blobs before getting runtime state" */);
         return {
             pending: this.pendingStateManager.getLocalState(),
             pendingAttachmentBlobs: this.blobManager.getPendingBlobs(),
-            snapshotBlobs: this.baseSnapshotBlobs,
-            baseSnapshot: this.context.baseSnapshot,
-            savedOps: this.savedOps,
         };
     }
     /**
@@ -1976,7 +2050,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                     [container_definitions_1.LoaderHeader.cache]: false,
                     [container_definitions_1.LoaderHeader.clientDetails]: {
                         capabilities: { interactive: false },
-                        type: summarizerClientElection_1.summarizerClientType,
+                        type: summary_1.summarizerClientType,
                     },
                     [driver_definitions_1.DriverHeader.summarizingClient]: true,
                     [container_definitions_1.LoaderHeader.reconnect]: false,
@@ -1991,20 +2065,6 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             return summarizer;
         };
     }
-    async processSavedOps(state) {
-        for (const op of state.savedOps) {
-            this.process(op, false);
-            await this.pendingStateManager.applyStashedOpsAt(op.sequenceNumber);
-        }
-        // we may not have seen every sequence number (because of system ops) so apply everything once we
-        // don't have any more saved ops
-        await this.pendingStateManager.applyStashedOpsAt();
-        // If it's not the case, we should take it into account when calculating dirty state.
-        (0, common_utils_1.assert)(this.context.attachState === container_definitions_1.AttachState.Attached, 0x3d5 /* this function is called for attached containers only */);
-        if (!this.hasPendingMessages()) {
-            this.updateDocumentDirtyState(false);
-        }
-    }
     validateSummaryHeuristicConfiguration(configuration) {
         // eslint-disable-next-line no-restricted-syntax
         for (const prop in configuration) {
@@ -2016,6 +2076,10 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             throw new container_utils_1.UsageError(`"minIdleTime" [${configuration.minIdleTime}] cannot be greater than "maxIdleTime" [${configuration.maxIdleTime}]`);
         }
     }
+    get groupedBatchingEnabled() {
+        const killSwitch = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableGroupedBatching");
+        return killSwitch !== true && this.runtimeOptions.enableGroupedBatching;
+    }
 }
 exports.ContainerRuntime = ContainerRuntime;
 /**