@fluidframework/container-runtime 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/lib/containerRuntime.js

@@ -1,33 +1,27 @@
 import { AttachState, LoaderHeader, } from "@fluidframework/container-definitions";
-import { assert, Trace, TypedEventEmitter, unreachableCase, } from "@fluidframework/common-utils";
+import { assert, Trace, TypedEventEmitter, unreachableCase } from "@fluidframework/common-utils";
 import { ChildLogger, raiseConnectedEvent, PerformanceEvent, TaggedLoggerAdapter, loggerToMonitoringContext, wrapError, } 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, gcTreeKey, channelsTreeName, } from "@fluidframework/runtime-definitions";
-import { addBlobToSummary, addSummarizeResultToSummary, addTreeToSummary, createRootSummarizerNodeWithGC, RequestParser, create404Response, exceptionToResponse, requestFluidObject, responseToException, seqFromTree, calculateStats, TelemetryContext, } from "@fluidframework/runtime-utils";
+import { FlushMode, FlushModeExperimental, gcTreeKey, channelsTreeName, } from "@fluidframework/runtime-definitions";
+import { addBlobToSummary, addSummarizeResultToSummary, addTreeToSummary, createRootSummarizerNodeWithGC, RequestParser, create404Response, exceptionToResponse, requestFluidObject, seqFromTree, calculateStats, TelemetryContext, } from "@fluidframework/runtime-utils";
 import { GCDataBuilder, trimLeadingAndTrailingSlashes } from "@fluidframework/garbage-collector";
 import { v4 as uuid } from "uuid";
 import { ContainerFluidHandleContext } from "./containerHandleContext";
 import { FluidDataStoreRegistry } from "./dataStoreRegistry";
-import { Summarizer } from "./summarizer";
-import { SummaryManager } from "./summaryManager";
-import { ReportOpPerfTelemetry, } from "./connectionTelemetry";
-import { PendingStateManager, } from "./pendingStateManager";
+import { ReportOpPerfTelemetry } from "./connectionTelemetry";
+import { PendingStateManager } from "./pendingStateManager";
 import { pkgVersion } from "./packageVersion";
 import { BlobManager } from "./blobManager";
 import { DataStores, getSummaryForDatastores } from "./dataStores";
-import { aliasBlobName, blobsTreeName, chunksBlobName, electedSummarizerBlobName, extractSummaryMetadataMessage, metadataBlobName, wrapSummaryInChannelsTree, } from "./summaryFormat";
-import { SummaryCollection } from "./summaryCollection";
-import { OrderedClientCollection, OrderedClientElection } from "./orderedClientElection";
-import { SummarizerClientElection, summarizerClientType } from "./summarizerClientElection";
+import { aliasBlobName, blobsTreeName, chunksBlobName, electedSummarizerBlobName, extractSummaryMetadataMessage, metadataBlobName, Summarizer, SummaryManager, wrapSummaryInChannelsTree, SummaryCollection, OrderedClientCollection, OrderedClientElection, SummarizerClientElection, summarizerClientType, RunWhileConnectedCoordinator, } from "./summary";
 import { formExponentialFn, Throttler } from "./throttler";
-import { RunWhileConnectedCoordinator } from "./runWhileConnectedCoordinator";
-import { GarbageCollector, GCNodeType, } from "./garbageCollection";
-import { channelToDataStore, isDataStoreAliasMessage, } from "./dataStore";
+import { GarbageCollector, GCNodeType, gcTombstoneGenerationOptionName, shouldAllowGcTombstoneEnforcement, } from "./gc";
+import { channelToDataStore, isDataStoreAliasMessage } from "./dataStore";
 import { BindBatchTracker } from "./batchTracker";
-import { SerializedSnapshotStorage } from "./serializedSnapshotStorage";
+import { SerializedSnapshotStorage, } from "./serializedSnapshotStorage";
 import { ScheduleManager } from "./scheduleManager";
 import { OpCompressor, OpDecompressor, Outbox, OpSplitter, RemoteMessageProcessor, } from "./opLifecycle";
 export var ContainerMessageType;
@@ -66,11 +60,6 @@ export 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 || (RuntimeHeaders = {}));
@@ -81,7 +70,6 @@ export const TombstoneResponseHeaderKey = "isTombstoned";
 /** Default values for Runtime Headers */
 export const defaultRuntimeHeaderData = {
     wait: true,
-    externalRequest: false,
     viaHandle: false,
     allowTombstone: false,
 };
@@ -134,8 +122,7 @@ export function getDeviceSpec() {
             };
         }
     }
-    catch (_a) {
-    }
+    catch (_a) { }
     return {};
 }
 /**
@@ -147,7 +134,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      * @internal
      */
     constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, requestHandler, summaryConfiguration) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         if (summaryConfiguration === void 0) { summaryConfiguration = Object.assign(Object.assign({}, DefaultSummaryConfiguration), (_a = runtimeOptions.summaryOptions) === null || _a === void 0 ? void 0 : _a.summaryConfigOverrides); }
         super();
         this.context = context;
@@ -160,7 +147,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.summaryConfiguration = summaryConfiguration;
         this.defaultMaxConsecutiveReconnects = 7;
         this._orderSequentiallyCalls = 0;
-        this.flushMicroTaskExists = false;
+        this.flushTaskExists = false;
         this.savedOps = [];
         this.consecutiveReconnects = 0;
         this.ensureNoDataModelChangesCalls = 0;
@@ -230,28 +217,48 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.nextSummaryNumber = loadSummaryNumber + 1;
         this.messageAtLastSummary = metadata === null || metadata === void 0 ? void 0 : metadata.message;
         this._connected = this.context.connected;
+        this.gcTombstoneEnforcementAllowed = shouldAllowGcTombstoneEnforcement((_c = metadata === null || metadata === void 0 ? void 0 : metadata.gcFeatureMatrix) === null || _c === void 0 ? void 0 : _c.tombstoneGeneration /* persisted */, this.runtimeOptions.gcOptions[gcTombstoneGenerationOptionName] /* current */);
         this.mc = loggerToMonitoringContext(ChildLogger.create(this.logger, "ContainerRuntime"));
-        const opSplitter = new OpSplitter(chunks, this.context.submitBatchFn, this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableCompressionChunking") === true ?
-            Number.POSITIVE_INFINITY : runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger);
+        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[gcTombstoneGenerationOptionName],
+            }),
+        });
+        this.disableAttachReorder = this.mc.config.getBoolean("Fluid.ContainerRuntime.disableAttachOpReorder");
+        const disableChunking = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableCompressionChunking");
+        const opSplitter = new OpSplitter(chunks, this.context.submitBatchFn, disableChunking === true ? Number.POSITIVE_INFINITY : runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger);
         this.remoteMessageProcessor = new RemoteMessageProcessor(opSplitter, new OpDecompressor());
         this.handleContext = new ContainerFluidHandleContext("", this);
         if (this.summaryConfiguration.state === "enabled") {
             this.validateSummaryHeuristicConfiguration(this.summaryConfiguration);
         }
-        this.enableOpReentryCheck = runtimeOptions.enableOpReentryCheck === true
-            // Allow for a break-glass config to override the options
-            && this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableOpReentryCheck") !== true;
+        const disableOpReentryCheck = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableOpReentryCheck");
+        this.enableOpReentryCheck =
+            runtimeOptions.enableOpReentryCheck === true &&
+                // Allow for a break-glass config to override the options
+                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;
+            (_d = this.mc.config.getNumber(maxConsecutiveReconnectsKey)) !== null && _d !== void 0 ? _d : this.defaultMaxConsecutiveReconnects;
+        if (runtimeOptions.flushMode === FlushModeExperimental.Async &&
+            ((_e = context.supportedFeatures) === null || _e === void 0 ? void 0 : _e.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;
+        }
+        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;
-        if (maxSnapshotCacheDurationMs !== undefined && maxSnapshotCacheDurationMs > 5 * 24 * 60 * 60 * 1000) {
+        const baseSnapshot = (_f = pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.baseSnapshot) !== null && _f !== void 0 ? _f : context.baseSnapshot;
+        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,
             // which dictates the value is either undefined or exactly 5 days in ms.
             // As long as the actual value is less than 5 days, the assumptions GC makes here are valid.
@@ -296,12 +303,15 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (baseSnapshot) {
             this.summarizerNode.updateBaseSummaryState(baseSnapshot);
         }
-        this.dataStores = new DataStores(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(getSummaryForDatastores(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(this.handleContext, blobManagerSnapshot, () => this.storage, (localId, blobId) => {
             if (!this.disposed) {
-                this.submit(ContainerMessageType.BlobAttach, undefined, undefined, { localId, blobId });
+                this.submit(ContainerMessageType.BlobAttach, undefined, undefined, {
+                    localId,
+                    blobId,
+                });
             }
-        }, (blobPath) => this.garbageCollector.nodeUpdated(blobPath, "Loaded"), (fromPath, toPath) => this.garbageCollector.addedOutboundReference(fromPath, toPath), this, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pendingAttachmentBlobs, () => this.getCurrentReferenceTimestampMs());
+        }, (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());
         this.scheduleManager = new ScheduleManager(context.deltaManager, this, () => this.clientId, ChildLogger.create(this.logger, "ScheduleManager"));
         this.pendingStateManager = new PendingStateManager({
             applyStashedOp: this.applyStashedOp.bind(this),
@@ -312,11 +322,14 @@ export class ContainerRuntime extends 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.DisableCompression");
+        const compressionOptions = disableCompression === true
+            ? {
                 minimumBatchSizeInBytes: Number.POSITIVE_INFINITY,
-                compressionAlgorithm: CompressionAlgorithms.lz4
-            } : runtimeOptions.compressionOptions;
+                compressionAlgorithm: CompressionAlgorithms.lz4,
+            }
+            : runtimeOptions.compressionOptions;
+        const disablePartialFlush = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisablePartialFlush");
         this.outbox = new Outbox({
             shouldSend: () => this.canSendOps(),
             pendingStateManager: this.pendingStateManager,
@@ -326,7 +339,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             config: {
                 compressionOptions,
                 maxBatchSizeInBytes: runtimeOptions.maxBatchSizeInBytes,
-                enableOpReentryCheck: this.enableOpReentryCheck,
+                disablePartialFlush: disablePartialFlush === true,
             },
             logger: this.mc.logger,
         });
@@ -334,8 +347,9 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.remoteMessageProcessor.clearPartialMessagesFor(clientId);
         });
         this.summaryCollection = new SummaryCollection(this.deltaManager, this.logger);
-        this.dirtyContainer = this.context.attachState !== AttachState.Attached
-            || this.pendingStateManager.hasPendingMessages();
+        this.dirtyContainer =
+            this.context.attachState !== AttachState.Attached ||
+                this.pendingStateManager.hasPendingMessages();
         this.context.updateDirtyContainerState(this.dirtyContainer);
         if (this.summariesDisabled) {
             this.mc.logger.sendTelemetryEvent({ eventName: "SummariesDisabled" });
@@ -399,12 +413,22 @@ export class ContainerRuntime extends 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,
+            }) }));
         ReportOpPerfTelemetry(this.context.clientId, this.deltaManager, this.logger);
         BindBatchTracker(this, this.logger);
     }
-    get IContainerRuntime() { return this; }
-    get IFluidRouter() { return this; }
+    get IContainerRuntime() {
+        return this;
+    }
+    get IFluidRouter() {
+        return this;
+    }
     /**
      * @deprecated - use loadRuntime instead.
      * Load the stores from a snapshot and returns the runtime.
@@ -445,7 +469,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      */
     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, } = 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;
@@ -457,13 +481,15 @@ export class ContainerRuntime extends TypedEventEmitter {
         });
         const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, enableOfflineLoad = false, compressionOptions = {
             minimumBatchSizeInBytes: Number.POSITIVE_INFINITY,
-            compressionAlgorithm: CompressionAlgorithms.lz4
+            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(() => { return context.storage; }, pendingRuntimeState.snapshotBlobs);
+        const storage = !pendingRuntimeState
+            ? context.storage
+            : new SerializedSnapshotStorage(() => {
+                return context.storage;
+            }, pendingRuntimeState.snapshotBlobs);
         const registry = new FluidDataStoreRegistry(registryEntries);
         const tryFetchBlob = async (blobName) => {
             const blobId = baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.blobs[blobName];
@@ -494,7 +520,8 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (!pendingRuntimeState && runtimeSequenceNumber !== undefined) {
             const protocolSequenceNumber = context.deltaManager.initialSequenceNumber;
             // Unless bypass is explicitly set, then take action when sequence numbers mismatch.
-            if (loadSequenceNumberVerification !== "bypass" && runtimeSequenceNumber !== protocolSequenceNumber) {
+            if (loadSequenceNumberVerification !== "bypass" &&
+                runtimeSequenceNumber !== protocolSequenceNumber) {
                 // "Load from summary, runtime metadata sequenceNumber !== initialSequenceNumber"
                 const error = new DataCorruptionError(
                 // pre-0.58 error message: SummaryMetadataMismatch
@@ -601,7 +628,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         var _a;
         return (_a = this.summarizerClientElection) === null || _a === void 0 ? void 0 : _a.electedClientId;
     }
-    get disposed() { return this._disposed; }
+    get disposed() {
+        return this._disposed;
+    }
     get summarizer() {
         assert(this._summarizer !== undefined, 0x257 /* "This is not summarizing container" */);
         return this._summarizer;
@@ -656,6 +685,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.emit("dispose");
         this.removeAllListeners();
     }
+    /**
+     * @deprecated 2.0.0-internal.3.2.0 ContainerRuntime is not an IFluidTokenProvider.  Token providers should be accessed using normal provider patterns.
+     */
     get IFluidTokenProvider() {
         var _a;
         if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.intelligence) {
@@ -711,7 +743,8 @@ export class ContainerRuntime extends TypedEventEmitter {
                         status: 200,
                         mimeType: "fluid/object",
                         value: blob,
-                    } : create404Response(request);
+                    }
+                    : create404Response(request);
             }
             else if (requestParser.pathParts.length > 0) {
                 const dataStore = await this.getDataStoreFromRequest(id, request);
@@ -732,7 +765,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         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];
@@ -746,22 +779,6 @@ export class ContainerRuntime extends 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 responseToException(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.
@@ -928,7 +945,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (reconnection) {
             this.consecutiveReconnects++;
             if (!this.shouldContinueReconnecting()) {
-                this.closeFn(DataProcessingError.create("Runtime detected too many reconnects with no progress syncing local ops. Batch of ops is likely too large (over 1Mb)", "setConnectionState", undefined, {
+                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,
@@ -1035,7 +1052,8 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (message.clientId === this.clientId && this.connected) {
             // Check to see if the signal was lost.
             if (this._perfSignalData.trackingSignalSequenceNumber !== undefined &&
-                envelope.clientSignalSequenceNumber > this._perfSignalData.trackingSignalSequenceNumber) {
+                envelope.clientSignalSequenceNumber >
+                    this._perfSignalData.trackingSignalSequenceNumber) {
                 this._perfSignalData.signalsLost++;
                 this._perfSignalData.trackingSignalSequenceNumber = undefined;
                 this.logger.sendErrorEvent({
@@ -1046,7 +1064,10 @@ export class ContainerRuntime extends TypedEventEmitter {
                     clientSignalSequenceNumber: envelope.clientSignalSequenceNumber,
                 });
             }
-            else if (envelope.clientSignalSequenceNumber === this._perfSignalData.trackingSignalSequenceNumber) {
+            else if (this.consecutiveReconnects === 0 &&
+                envelope.clientSignalSequenceNumber ===
+                    this._perfSignalData.trackingSignalSequenceNumber) {
+                // only logging for the first connection and the trackingSignalSequenceNUmber.
                 this.sendSignalTelemetryEvent(envelope.clientSignalSequenceNumber);
                 this._perfSignalData.trackingSignalSequenceNumber = undefined;
             }
@@ -1133,7 +1154,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         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();
+        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, id = uuid(), props) {
@@ -1148,7 +1171,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      * Are we in the middle of batching ops together?
      */
     currentlyBatching() {
-        return this.flushMode === FlushMode.TurnBased || this._orderSequentiallyCalls !== 0;
+        return this.flushMode !== FlushMode.Immediate || this._orderSequentiallyCalls !== 0;
     }
     getQuorum() {
         return this.context.quorum;
@@ -1266,7 +1289,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         const { fullTree = false, trackState = true, summaryLogger = this.mc.logger, runGC = this.garbageCollector.shouldRunGC, runSweep, fullGC, } = options;
         const telemetryContext = new TelemetryContext();
         // Add the options that are used to generate this summary to the telemetry context.
-        telemetryContext.setAll("fluid_Summarize", "Options", {
+        telemetryContext.setMultiple("fluid_Summarize", "Options", {
             fullTree,
             trackState,
             runGC,
@@ -1278,7 +1301,10 @@ export class ContainerRuntime extends TypedEventEmitter {
             gcStats = await this.collectGarbage({ logger: summaryLogger, runSweep, fullGC }, telemetryContext);
         }
         const { stats, summary } = await this.summarizerNode.summarize(fullTree, trackState, telemetryContext);
-        this.logger.sendTelemetryEvent({ eventName: "SummarizeTelemetry", details: telemetryContext.serialize() });
+        this.logger.sendTelemetryEvent({
+            eventName: "SummarizeTelemetry",
+            details: telemetryContext.serialize(),
+        });
         assert(summary.type === SummaryType.Tree, 0x12f /* "Container Runtime's summarize should always return a tree" */);
         return { stats, summary, gcStats };
     }
@@ -1329,6 +1355,22 @@ export class ContainerRuntime extends 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.
@@ -1444,8 +1486,12 @@ export class ContainerRuntime extends 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}`;
@@ -1546,8 +1592,8 @@ 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
-                && latestSnapshotVersionId !== undefined) {
+            if ((lastAck === null || lastAck === void 0 ? void 0 : lastAck.summaryAck.contents.handle) !== latestSnapshotVersionId &&
+                latestSnapshotVersionId !== undefined) {
                 summaryContext = {
                     proposalHandle: undefined,
                     ackHandle: latestSnapshotVersionId,
@@ -1590,7 +1636,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
             let clientSequenceNumber;
             try {
-                clientSequenceNumber = this.submitSummaryMessage(summaryMessage);
+                clientSequenceNumber = this.submitSummaryMessage(summaryMessage, summaryRefSeqNum);
             }
             catch (error) {
                 return Object.assign(Object.assign({ stage: "upload" }, uploadData), { error });
@@ -1604,6 +1650,9 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.summarizerNode.clearSummary();
             // Restart the delta manager
             this.deltaManager.inbound.resume();
+            if (shouldPauseInboundSignal) {
+                this.deltaManager.inboundSignal.resume();
+            }
         }
     }
     hasPendingMessages() {
@@ -1649,14 +1698,16 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.verifyCanSubmitOps();
         // There should be no ops in detached container state!
         assert(this.attachState !== AttachState.Detached, 0x132 /* "sending ops in detached container" */);
-        const deserializedContent = { type, contents };
-        const serializedContent = JSON.stringify(deserializedContent);
+        const serializedContent = JSON.stringify({ type, contents });
         if (this.deltaManager.readOnlyInfo.readonly) {
-            this.logger.sendTelemetryEvent({ eventName: "SubmitOpInReadonly", connected: this.connected });
+            this.logger.sendTelemetryEvent({
+                eventName: "SubmitOpInReadonly",
+                connected: this.connected,
+            });
         }
         const message = {
             contents: serializedContent,
-            deserializedContent,
+            deserializedContent: JSON.parse(serializedContent),
             metadata,
             localOpMetadata,
             referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
@@ -1682,8 +1733,9 @@ export class ContainerRuntime extends TypedEventEmitter {
             //    issue than sending.
             // Please note that this does not change file format, so it can be disabled in the future if this
             // 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) {
+            if (this.currentlyBatching() &&
+                type === ContainerMessageType.Attach &&
+                this.disableAttachReorder !== true) {
                 this.outbox.submitAttach(message);
             }
             else {
@@ -1692,13 +1744,8 @@ export class ContainerRuntime extends 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) {
@@ -1709,14 +1756,47 @@ export class ContainerRuntime extends 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 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 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:
+                assert(this._orderSequentiallyCalls > 0, 0x587 /* Unreachable unless running under orderSequentially */);
+                break;
+        }
+    }
+    submitSummaryMessage(contents, referenceSequenceNumber) {
         this.verifyNotClosed();
         assert(this.connected, 0x133 /* "Container disconnected when trying to submit system message" */);
         // 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)
+            ? this.context.submitSummaryFn(contents, referenceSequenceNumber)
             : this.context.submitFn(MessageType.Summarize, contents, false);
     }
     /**
@@ -1813,7 +1893,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         // 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 () => {
-            const fetchResult = await this.fetchLatestSnapshotFromStorage(summaryLogger, {
+            let fetchResult = await this.fetchLatestSnapshotFromStorage(summaryLogger, {
                 eventName: "RefreshLatestSummaryAckFetch",
                 ackHandle,
                 targetSequenceNumber: summaryRefSeq,
@@ -1829,13 +1909,21 @@ export class ContainerRuntime extends TypedEventEmitter {
              * state.
              */
             if (fetchResult.latestSnapshotRefSeq < summaryRefSeq) {
-                const error = DataProcessingError.create("Fetched snapshot is older than the received ack", "RefreshLatestSummaryAck", undefined /* sequencedMessage */, {
+                /* before failing, let's try to retrieve the latest snapshot for that specific ackHandle */
+                fetchResult = await this.fetchSnapshotFromStorage(summaryLogger, {
+                    eventName: "RefreshLatestSummaryAckFetch",
                     ackHandle,
-                    summaryRefSeq,
-                    latestSnapshotRefSeq: fetchResult.latestSnapshotRefSeq,
-                });
-                this.closeFn(error);
-                throw error;
+                    targetSequenceNumber: summaryRefSeq,
+                }, readAndParseBlob, ackHandle);
+                if (fetchResult.latestSnapshotRefSeq < summaryRefSeq) {
+                    const error = DataProcessingError.create("Fetched snapshot is older than the received ack", "RefreshLatestSummaryAck", undefined /* sequencedMessage */, {
+                        ackHandle,
+                        summaryRefSeq,
+                        fetchedSnapshotRefSeq: fetchResult.latestSnapshotRefSeq,
+                    });
+                    this.closeFn(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.
@@ -1870,10 +1958,13 @@ export class ContainerRuntime extends TypedEventEmitter {
         return { latestSnapshotRefSeq, latestSnapshotVersionId: versionId };
     }
     async fetchLatestSnapshotFromStorage(logger, event, readAndParseBlob) {
+        return this.fetchSnapshotFromStorage(logger, event, readAndParseBlob, null /* latest */);
+    }
+    async fetchSnapshotFromStorage(logger, event, readAndParseBlob, versionId) {
         return PerformanceEvent.timedExecAsync(logger, event, async (perfEvent) => {
             const stats = {};
             const trace = Trace.start();
-            const versions = await this.storage.getVersions(null, 1, "refreshLatestSummaryAckFromServer", FetchSource.noCache);
+            const versions = await this.storage.getVersions(versionId, 1, "refreshLatestSummaryAckFromServer", versionId === null ? FetchSource.noCache : undefined);
             assert(!!versions && !!versions[0], 0x137 /* "Failed to get version from storage" */);
             stats.getVersionDuration = trace.trace().duration;
             const maybeSnapshot = await this.storage.getSnapshotTree(versions[0]);
@@ -1893,13 +1984,15 @@ export class ContainerRuntime extends TypedEventEmitter {
     notifyAttaching(snapshot) {
         var _a;
         if ((_a = this.mc.config.getBoolean("enableOfflineLoad")) !== null && _a !== void 0 ? _a : this.runtimeOptions.enableOfflineLoad) {
-            this.baseSnapshotBlobs = SerializedSnapshotStorage.serializeTreeWithBlobContents(snapshot);
+            this.baseSnapshotBlobs =
+                SerializedSnapshotStorage.serializeTreeWithBlobContents(snapshot);
         }
     }
     async initializeBaseSnapshotBlobs() {
         var _a;
         if (!((_a = this.mc.config.getBoolean("enableOfflineLoad")) !== null && _a !== void 0 ? _a : this.runtimeOptions.enableOfflineLoad) ||
-            this.attachState !== AttachState.Attached || this.context.pendingLocalState) {
+            this.attachState !== AttachState.Attached ||
+            this.context.pendingLocalState) {
             return;
         }
         assert(!!this.context.baseSnapshot, 0x2e5 /* "Must have a base snapshot" */);