@fluidframework/container-runtime 2.0.0-rc.1.0.3 → 2.0.0-rc.2.0.0

package/lib/{containerRuntime.mjs → containerRuntime.js}

@@ -1,31 +1,29 @@
 import { AttachState, LoaderHeader, } from "@fluidframework/container-definitions";
-import { assert, delay, LazyPromise } from "@fluidframework/core-utils";
+import { assert, Deferred, delay, LazyPromise, PromiseCache } from "@fluidframework/core-utils";
 import { Trace, TypedEventEmitter } from "@fluid-internal/client-utils";
-import { createChildLogger, createChildMonitoringContext, DataCorruptionError, DataProcessingError, GenericError, raiseConnectedEvent, PerformanceEvent, 
-// eslint-disable-next-line import/no-deprecated
-TaggedLoggerAdapter, wrapError, UsageError, LoggingError, } from "@fluidframework/telemetry-utils";
+import { createChildLogger, createChildMonitoringContext, DataCorruptionError, DataProcessingError, GenericError, raiseConnectedEvent, PerformanceEvent, TaggedLoggerAdapter, wrapError, UsageError, LoggingError, createSampledLogger, loggerToMonitoringContext, } from "@fluidframework/telemetry-utils";
 import { DriverHeader, FetchSource, } from "@fluidframework/driver-definitions";
 import { readAndParse } from "@fluidframework/driver-utils";
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { FlushMode, FlushModeExperimental, gcTreeKey, channelsTreeName, } from "@fluidframework/runtime-definitions";
-import { addBlobToSummary, addSummarizeResultToSummary, addTreeToSummary, RequestParser, create404Response, exceptionToResponse, GCDataBuilder, seqFromTree, calculateStats, TelemetryContext, responseToException, } from "@fluidframework/runtime-utils";
+import { addBlobToSummary, addSummarizeResultToSummary, RequestParser, create404Response, exceptionToResponse, GCDataBuilder, seqFromTree, calculateStats, TelemetryContext, responseToException, } from "@fluidframework/runtime-utils";
 import { v4 as uuid } from "uuid";
-import { ContainerFluidHandleContext } from "./containerHandleContext.mjs";
-import { FluidDataStoreRegistry } from "./dataStoreRegistry.mjs";
-import { ReportOpPerfTelemetry } from "./connectionTelemetry.mjs";
-import { PendingStateManager, } from "./pendingStateManager.mjs";
-import { pkgVersion } from "./packageVersion.mjs";
-import { BlobManager } from "./blobManager.mjs";
-import { DataStores, getSummaryForDatastores } from "./dataStores.mjs";
-import { aliasBlobName, blobsTreeName, chunksBlobName, createRootSummarizerNodeWithGC, electedSummarizerBlobName, extractSummaryMetadataMessage, idCompressorBlobName, metadataBlobName, Summarizer, SummaryManager, wrapSummaryInChannelsTree, SummaryCollection, OrderedClientCollection, OrderedClientElection, SummarizerClientElection, summarizerClientType, RunWhileConnectedCoordinator, RetriableSummaryError, } from "./summary/index.mjs";
-import { formExponentialFn, Throttler } from "./throttler.mjs";
-import { GarbageCollector, GCNodeType, gcGenerationOptionName, trimLeadingAndTrailingSlashes, } from "./gc/index.mjs";
-import { channelToDataStore, isDataStoreAliasMessage } from "./dataStore.mjs";
-import { BindBatchTracker } from "./batchTracker.mjs";
-import { ScheduleManager } from "./scheduleManager.mjs";
-import { OpCompressor, OpDecompressor, Outbox, OpSplitter, RemoteMessageProcessor, OpGroupingManager, getLongStack, } from "./opLifecycle/index.mjs";
-import { DeltaManagerSummarizerProxy } from "./deltaManagerSummarizerProxy.mjs";
-import { ContainerMessageType, } from "./messageTypes.mjs";
+import { ContainerFluidHandleContext } from "./containerHandleContext.js";
+import { FluidDataStoreRegistry } from "./dataStoreRegistry.js";
+import { ReportOpPerfTelemetry } from "./connectionTelemetry.js";
+import { PendingStateManager, } from "./pendingStateManager.js";
+import { pkgVersion } from "./packageVersion.js";
+import { BlobManager } from "./blobManager.js";
+import { ChannelCollection, getSummaryForDatastores, wrapContext } from "./channelCollection.js";
+import { aliasBlobName, blobsTreeName, chunksBlobName, createRootSummarizerNodeWithGC, electedSummarizerBlobName, extractSummaryMetadataMessage, idCompressorBlobName, metadataBlobName, Summarizer, SummaryManager, wrapSummaryInChannelsTree, SummaryCollection, OrderedClientCollection, OrderedClientElection, SummarizerClientElection, summarizerClientType, RunWhileConnectedCoordinator, RetriableSummaryError, rootHasIsolatedChannels, } from "./summary/index.js";
+import { formExponentialFn, Throttler } from "./throttler.js";
+import { GarbageCollector, GCNodeType, gcGenerationOptionName, } from "./gc/index.js";
+import { channelToDataStore } from "./dataStore.js";
+import { BindBatchTracker } from "./batchTracker.js";
+import { ScheduleManager } from "./scheduleManager.js";
+import { OpCompressor, OpDecompressor, Outbox, OpSplitter, RemoteMessageProcessor, OpGroupingManager, getLongStack, } from "./opLifecycle/index.js";
+import { DeltaManagerSummarizerProxy } from "./deltaManagerSummarizerProxy.js";
+import { ContainerMessageType, } from "./messageTypes.js";
 /**
  * Utility to implement compat behaviors given an unknown message type
  * The parameters are typed to support compile-time enforcement of handling all known types/behaviors
@@ -55,26 +53,6 @@ export const DefaultSummaryConfiguration = {
     runtimeOpWeight: 1.0,
     nonRuntimeHeuristicThreshold: 20,
 };
-/**
- * Accepted header keys for requests coming to the runtime.
- * @internal
- */
-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 coming from an IFluidHandle. */
-    RuntimeHeaders["viaHandle"] = "viaHandle";
-})(RuntimeHeaders || (RuntimeHeaders = {}));
-/** True if a tombstoned object should be returned without erroring
- * @alpha
- */
-export const AllowTombstoneRequestHeaderKey = "allowTombstone"; // Belongs in the enum above, but avoiding the breaking change
-/**
- * [IRRELEVANT IF throwOnInactiveLoad OPTION NOT SET] True if an inactive object should be returned without erroring
- * @internal
- */
-export const AllowInactiveRequestHeaderKey = "allowInactive"; // Belongs in the enum above, but avoiding the breaking change
 /**
  * Tombstone error responses will have this header set to true
  * @alpha
@@ -243,7 +221,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         // back-compat: Remove the TaggedLoggerAdapter fallback once all the host are using loader > 0.45
         const backCompatContext = context;
         const passLogger = backCompatContext.taggedLogger ??
-            // eslint-disable-next-line import/no-deprecated
             new TaggedLoggerAdapter(backCompatContext.logger);
         const logger = createChildLogger({
             logger: passLogger,
@@ -253,7 +230,8 @@ export class ContainerRuntime extends TypedEventEmitter {
                 },
             },
         });
-        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, compressionOptions = defaultCompressionConfig, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, enableRuntimeIdCompressor = false, chunkSizeInBytes = defaultChunkSizeInBytes, enableOpReentryCheck = false, enableGroupedBatching = false, } = runtimeOptions;
+        const mc = loggerToMonitoringContext(logger);
+        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, compressionOptions = defaultCompressionConfig, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, enableRuntimeIdCompressor = "off", chunkSizeInBytes = defaultChunkSizeInBytes, enableOpReentryCheck = false, enableGroupedBatching = false, } = runtimeOptions;
         const registry = new FluidDataStoreRegistry(registryEntries);
         const tryFetchBlob = async (blobName) => {
             const blobId = context.baseSnapshot?.blobs[blobName];
@@ -298,21 +276,62 @@ export class ContainerRuntime extends TypedEventEmitter {
                 }
             }
         }
-        const idCompressorEnabled = metadata?.idCompressorEnabled ?? runtimeOptions.enableRuntimeIdCompressor ?? false;
-        let idCompressor;
-        if (idCompressorEnabled) {
+        // Enabling the IdCompressor is a one-way operation and we only want to
+        // allow new containers to turn it on
+        let idCompressorMode;
+        if (existing) {
+            // This setting has to be sticky for correctness:
+            // 1) if compressior is OFF, it can't be enabled, as already running clients (in given document session) do not know
+            //    how to process compressor ops
+            // 2) if it's ON, then all sessions should load compressor right away
+            // 3) Same logic applies for "delayed" mode
+            // Maybe in the future we will need to enabled (and figure how to do it safely) "delayed" -> "on" change.
+            // We could do "off" -> "on" transtition too, if all clients start loading compressor (but not using it initially) and do so for a while -
+            // this will allow clients to eventually to disregard "off" setting (when it's safe so) and start using compressor in future sessions.
+            // Everyting is possible, but it needs to be designed and executed carefully, when such need arises.
+            idCompressorMode = metadata?.idCompressorMode ?? "off";
+        }
+        else {
+            // FG overwrite
+            const enabled = mc.config.getBoolean("Fluid.ContainerRuntime.IdCompressorEnabled");
+            switch (enabled) {
+                case true:
+                    idCompressorMode = "on";
+                    break;
+                case false:
+                    idCompressorMode = "off";
+                    break;
+                default:
+                    idCompressorMode = enableRuntimeIdCompressor;
+                    break;
+            }
+        }
+        const createIdCompressorFn = async () => {
             const { createIdCompressor, deserializeIdCompressor, createSessionId } = await import("@fluidframework/id-compressor");
+            /**
+             * Because the IdCompressor emits so much telemetry, this function is used to sample
+             * approximately 5% of all clients. Only the given percentage of sessions will emit telemetry.
+             */
+            const idCompressorEventSampler = (() => {
+                const isIdCompressorTelemetryEnabled = Math.random() < 0.05;
+                return {
+                    sample: () => {
+                        return isIdCompressorTelemetryEnabled;
+                    },
+                };
+            })();
+            const compressorLogger = createSampledLogger(logger, idCompressorEventSampler);
             const pendingLocalState = context.pendingLocalState;
             if (pendingLocalState?.pendingIdCompressorState !== undefined) {
-                idCompressor = deserializeIdCompressor(pendingLocalState.pendingIdCompressorState);
+                return deserializeIdCompressor(pendingLocalState.pendingIdCompressorState, compressorLogger);
             }
             else if (serializedIdCompressor !== undefined) {
-                idCompressor = deserializeIdCompressor(serializedIdCompressor, createSessionId());
+                return deserializeIdCompressor(serializedIdCompressor, createSessionId(), compressorLogger);
             }
             else {
-                idCompressor = createIdCompressor(logger);
+                return createIdCompressor(compressorLogger);
             }
-        }
+        };
         const runtime = new containerRuntimeCtor(context, registry, metadata, electedSummarizerData, chunks ?? [], aliases ?? [], {
             summaryOptions,
             gcOptions,
@@ -324,7 +343,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             enableRuntimeIdCompressor,
             enableOpReentryCheck,
             enableGroupedBatching,
-        }, containerScope, logger, existing, blobManagerSnapshot, context.storage, idCompressor, provideEntryPoint, requestHandler, undefined);
+        }, containerScope, logger, existing, blobManagerSnapshot, context.storage, createIdCompressorFn, idCompressorMode, provideEntryPoint, requestHandler, undefined);
         // Apply stashed ops with a reference sequence number equal to the sequence number of the snapshot,
         // or zero. This must be done before Container replays saved ops.
         await runtime.pendingStateManager.applyStashedOpsAt(runtimeSequenceNumber ?? 0);
@@ -338,6 +357,9 @@ export class ContainerRuntime extends TypedEventEmitter {
     get storage() {
         return this._storage;
     }
+    get containerRuntime() {
+        return this;
+    }
     get flushMode() {
         return this._flushMode;
     }
@@ -350,6 +372,25 @@ export class ContainerRuntime extends TypedEventEmitter {
     get attachState() {
         return this._getAttachState();
     }
+    /**
+     * See IContainerRuntimeBase.idCompressor() for details.
+     */
+    get idCompressor() {
+        // Expose ID Compressor only if it's On from the start.
+        // If container uses delayed mode, then we can only expose generateDocumentUniqueId() and nothing else.
+        // That's because any other usage will require immidiate loading of ID Compressor in next sessions in order
+        // to reason over such things as session ID space.
+        if (this.idCompressorMode === "on") {
+            assert(this._idCompressor !== undefined, 0x8ea /* compressor should have been loaded */);
+            return this._idCompressor;
+        }
+    }
+    /**
+     * See IContainerRuntimeBase.generateDocumentUniqueId() for details.
+     */
+    generateDocumentUniqueId() {
+        return this._idCompressor?.generateDocumentUniqueId() ?? uuid();
+    }
     get IFluidHandleContext() {
         return this.handleContext;
     }
@@ -387,9 +428,6 @@ export class ContainerRuntime extends TypedEventEmitter {
     isSummariesDisabled() {
         return this.summaryConfiguration.state === "disabled";
     }
-    isHeuristicsDisabled() {
-        return this.summaryConfiguration.state === "disableHeuristics";
-    }
     getMaxOpsSinceLastSummary() {
         return this.summaryConfiguration.state !== "disabled"
             ? this.summaryConfiguration.maxOpsSinceLastSummary
@@ -414,7 +452,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         return this.garbageCollector.throwOnTombstoneUsage;
     }
     /***/
-    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, idCompressor, provideEntryPoint, requestHandler, summaryConfiguration = {
+    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, createIdCompressor, idCompressorMode, provideEntryPoint, requestHandler, summaryConfiguration = {
         // the defaults
         ...DefaultSummaryConfiguration,
         // the runtime configuration overrides
@@ -422,13 +460,24 @@ export class ContainerRuntime extends TypedEventEmitter {
     }) {
         super();
         this.registry = registry;
+        this.metadata = metadata;
         this.runtimeOptions = runtimeOptions;
         this.containerScope = containerScope;
         this.logger = logger;
         this._storage = _storage;
+        this.createIdCompressor = createIdCompressor;
+        this.idCompressorMode = idCompressorMode;
         this.requestHandler = requestHandler;
         this.summaryConfiguration = summaryConfiguration;
         this.imminentClosure = false;
+        // We accumulate Id compressor Ops while Id compressor is not loaded yet (only for "delayed" mode)
+        // Once it loads, it will process all such ops and we will stop accumulating further ops - ops will be processes as they come in.
+        this.pendingIdCompressorOps = [];
+        /**
+         * True if we have ID compressor loading in-flight (async operation). Useful only for
+         * this.idCompressorMode === "delayed" mode
+         */
+        this.compressorLoadInitiated = false;
         this.defaultMaxConsecutiveReconnects = 7;
         this._orderSequentiallyCalls = 0;
         this.flushTaskExists = false;
@@ -450,6 +499,13 @@ export class ContainerRuntime extends TypedEventEmitter {
             signalTimestamp: 0,
             trackingSignalSequenceNumber: undefined,
         };
+        /**
+         * It a cache for holding mapping for loading groupIds with its snapshot from the service. Add expiry policy of 1 minute.
+         * Starting with 1 min and based on recorded usage we can tweak it later on.
+         */
+        this.snapshotCacheForLoadingGroupIds = new PromiseCache({
+            expiry: { policy: "absolute", durationMs: 60000 },
+        });
         const { options, clientDetails, connected, baseSnapshot, submitFn, submitBatchFn, submitSummaryFn, submitSignalFn, disposeFn, closeFn, deltaManager, quorum, audience, loader, pendingLocalState, supportedFeatures, } = context;
         this.innerDeltaManager = deltaManager;
         this.deltaManager = new DeltaManagerSummarizerProxy(this.innerDeltaManager);
@@ -459,7 +515,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.submitBatchFn = submitBatchFn;
         this.submitSummaryFn = submitSummaryFn;
         this.submitSignalFn = submitSignalFn;
-        this.options = options;
+        // TODO: After IContainerContext.options is removed, we'll just create a new blank object {} here.
+        // Values are generally expected to be set from the runtime side.
+        this.options = options ?? {};
         this.clientDetails = clientDetails;
         this.isSummarizerClient = this.clientDetails.type === summarizerClientType;
         this.loadedFromVersionId = context.getLoadedFromVersion()?.id;
@@ -497,9 +555,6 @@ export class ContainerRuntime extends TypedEventEmitter {
             // summaryNumber was renamed from summaryCount. For older docs that haven't been opened for a long time,
             // the count is reset to 0.
             loadSummaryNumber = metadata?.summaryNumber ?? 0;
-            // Enabling the IdCompressor is a one-way operation and we only want to
-            // allow new containers to turn it on
-            this.idCompressorEnabled = metadata?.idCompressorEnabled ?? false;
         }
         else {
             this.createContainerMetadata = {
@@ -507,9 +562,6 @@ export class ContainerRuntime extends TypedEventEmitter {
                 createContainerTimestamp: Date.now(),
             };
             loadSummaryNumber = 0;
-            this.idCompressorEnabled =
-                this.mc.config.getBoolean("Fluid.ContainerRuntime.IdCompressorEnabled") ??
-                    idCompressor !== undefined;
         }
         this.nextSummaryNumber = loadSummaryNumber + 1;
         this.messageAtLastSummary = metadata?.message;
@@ -544,12 +596,8 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // 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();
-        if (this.idCompressorEnabled) {
-            this.idCompressor = idCompressor;
-        }
         this.maxConsecutiveReconnects =
             this.mc.config.getNumber(maxConsecutiveReconnectsKey) ??
                 this.defaultMaxConsecutiveReconnects;
@@ -563,13 +611,15 @@ export class ContainerRuntime extends TypedEventEmitter {
             this._flushMode = runtimeOptions.flushMode;
         }
         const pendingRuntimeState = pendingLocalState;
-        const maxSnapshotCacheDurationMs = this._storage?.policies?.maximumCacheDurationMs;
-        if (maxSnapshotCacheDurationMs !== undefined &&
-            maxSnapshotCacheDurationMs > 5 * 24 * 60 * 60 * 1000) {
-            // This is a runtime enforcement of what's already explicit in the policy's type itself,
-            // 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.
-            throw new UsageError("Driver's maximumCacheDurationMs policy cannot exceed 5 days");
+        if (context.attachState === AttachState.Attached) {
+            const maxSnapshotCacheDurationMs = this._storage?.policies?.maximumCacheDurationMs;
+            if (maxSnapshotCacheDurationMs !== undefined &&
+                maxSnapshotCacheDurationMs > 5 * 24 * 60 * 60 * 1000) {
+                // This is a runtime enforcement of what's already explicit in the policy's type itself,
+                // 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.
+                throw new UsageError("Driver's maximumCacheDurationMs policy cannot exceed 5 days");
+            }
         }
         this.garbageCollector = GarbageCollector.create({
             runtime: this,
@@ -584,6 +634,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             getLastSummaryTimestampMs: () => this.messageAtLastSummary?.timestamp,
             readAndParseBlob: async (id) => readAndParse(this.storage, id),
             submitMessage: (message) => this.submit(message),
+            sessionExpiryTimerStarted: pendingRuntimeState?.sessionExpiryTimerStarted,
         });
         const loadedFromSequenceNumber = this.deltaManager.initialSequenceNumber;
         this.summarizerNode = createRootSummarizerNodeWithGC(createChildLogger({ logger: this.logger, namespace: "SummarizerNode" }), 
@@ -596,9 +647,6 @@ export class ContainerRuntime extends TypedEventEmitter {
             // Must set to false to prevent sending summary handle which would be pointing to
             // a summary with an older protocol state.
             canReuseHandle: false,
-            // Must set to true to throw on any data stores failure that was too severe to be handled.
-            // We also are not decoding the base summaries at the root.
-            throwOnFailure: true,
             // If GC should not run, let the summarizer node know so that it does not track GC state.
             gcDisabled: !this.garbageCollector.shouldRunGC,
         }, 
@@ -609,7 +657,16 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (baseSnapshot) {
             this.summarizerNode.updateBaseSummaryState(baseSnapshot);
         }
-        this.dataStores = new DataStores(getSummaryForDatastores(baseSnapshot, metadata), this, (attachMsg) => this.submit({ type: ContainerMessageType.Attach, contents: attachMsg }), (id, createParam) => (summarizeInternal, getGCDataFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), (path) => this.garbageCollector.isNodeDeleted(path), new Map(dataStoreAliasMap));
+        const parentContext = wrapContext(this);
+        // Due to a mismatch between different layers in terms of
+        // what is the interface of passing signals, we need the
+        // downstream stores to wrap the signal.
+        parentContext.submitSignal = (type, content, targetClientId) => {
+            const envelope1 = content;
+            const envelope2 = this.createNewSignalEnvelope(envelope1.address, type, envelope1.contents);
+            return this.submitSignalFn(envelope2, targetClientId);
+        };
+        this.channelCollection = new ChannelCollection(getSummaryForDatastores(baseSnapshot, metadata), parentContext, this.mc.logger, (path, reason, timestampMs, packagePath, request, headerData) => this.garbageCollector.nodeUpdated(path, reason, timestampMs, packagePath, request, headerData), (path) => this.garbageCollector.isNodeDeleted(path), new Map(dataStoreAliasMap), async (runtime) => provideEntryPoint);
         this.blobManager = new BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (localId, blobId) => {
             if (!this.disposed) {
                 this.submit({ type: ContainerMessageType.BlobAttach, contents: undefined }, undefined, {
@@ -627,6 +684,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             reSubmit: this.reSubmit.bind(this),
             reSubmitBatch: this.reSubmitBatch.bind(this),
             isActiveConnection: () => this.innerDeltaManager.active,
+            isAttached: () => this.attachState !== AttachState.Detached,
         }, pendingRuntimeState?.pending, this.logger);
         const disableCompression = this.mc.config.getBoolean("Fluid.ContainerRuntime.CompressionDisabled");
         const compressionOptions = disableCompression === true
@@ -718,7 +776,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // throttling function increases exponentially (0ms, 40ms, 80ms, 160ms, etc)
                 formExponentialFn({ coefficient: 20, initialDelay: 0 })), {
                     initialDelayMs: this.initialSummarizerDelayMs,
-                }, this.heuristicsDisabled);
+                });
                 this.summaryManager.on("summarize", (eventProps) => {
                     this.emit("summarize", eventProps);
                 });
@@ -733,25 +791,26 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.mc.logger.sendTelemetryEvent({
             eventName: "ContainerLoadStats",
             ...this.createContainerMetadata,
-            ...this.dataStores.containerLoadStats,
+            ...this.channelCollection.containerLoadStats,
             summaryNumber: loadSummaryNumber,
             summaryFormatVersion: metadata?.summaryFormatVersion,
             disableIsolatedChannels: metadata?.disableIsolatedChannels,
             gcVersion: metadata?.gcFeature,
             options: JSON.stringify(runtimeOptions),
+            idCompressorModeMetadata: metadata?.idCompressorMode,
+            idCompressorMode: this.idCompressorMode,
             featureGates: JSON.stringify({
                 disableCompression,
                 disableOpReentryCheck,
                 disableChunking,
                 disableAttachReorder: this.disableAttachReorder,
                 disablePartialFlush,
-                idCompressorEnabled: this.idCompressorEnabled,
                 closeSummarizerDelayOverride,
             }),
             telemetryDocumentId: this.telemetryDocumentId,
             groupedBatchingEnabled: this.groupedBatchingEnabled,
         });
-        ReportOpPerfTelemetry(this.clientId, this.deltaManager, this.logger);
+        ReportOpPerfTelemetry(this.clientId, this.deltaManager, this, this.logger);
         BindBatchTracker(this, this.logger);
         this.entryPoint = new LazyPromise(async () => {
             if (this.isSummarizerClient) {
@@ -760,11 +819,29 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
             return provideEntryPoint(this);
         });
+        // If we loaded from pending state, then we need to skip any ops that are already accounted in such
+        // saved state, i.e. all the ops marked by Loader layer sa savedOp === true.
+        this.skipSavedCompressorOps = pendingRuntimeState?.pendingIdCompressorState !== undefined;
+    }
+    getCreateChildSummarizerNodeFn(id, createParam) {
+        return (summarizeInternal, getGCDataFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn);
+    }
+    deleteChildSummarizerNode(id) {
+        return this.summarizerNode.deleteChild(id);
+    }
+    makeLocallyVisible() {
+        assert(false, 0x8eb /* should not be called */);
     }
     /**
      * Initializes the state from the base snapshot this container runtime loaded from.
      */
     async initializeBaseState() {
+        if (this.idCompressorMode === "on" ||
+            (this.idCompressorMode === "delayed" && this.connected)) {
+            // This is called from loadRuntime(), long before we process any ops, so there should be no ops accumulated yet.
+            assert(this.pendingIdCompressorOps.length === 0, 0x8ec /* no pending ops */);
+            this._idCompressor = await this.createIdCompressor();
+        }
         await this.garbageCollector.initializeBaseState();
     }
     dispose(error) {
@@ -783,11 +860,110 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         this.garbageCollector.dispose();
         this._summarizer?.dispose();
-        this.dataStores.dispose();
+        this.channelCollection.dispose();
         this.pendingStateManager.dispose();
         this.emit("dispose");
         this.removeAllListeners();
     }
+    /**
+     * Api to fetch the snapshot from the service for a loadingGroupIds.
+     * @param loadingGroupIds - LoadingGroupId for which the snapshot is asked for.
+     * @param pathParts - Parts of the path, which we want to extract from the snapshot tree.
+     * @returns - snapshotTree and the sequence number of the snapshot.
+     */
+    async getSnapshotForLoadingGroupId(loadingGroupIds, pathParts) {
+        const sortedLoadingGroupIds = loadingGroupIds.sort();
+        assert(this.storage.getSnapshot !== undefined, 0x8ed /* getSnapshot api should be defined if used */);
+        let loadedFromCache = true;
+        // Lookup up in the cache, if not present then make the network call as multiple datastores could
+        // be in same loading group. So, once we have fetched the snapshot for that loading group on
+        // any request, then cache that as same group could be requested in future too.
+        const snapshot = await this.snapshotCacheForLoadingGroupIds.addOrGet(sortedLoadingGroupIds.join(), async () => {
+            assert(this.storage.getSnapshot !== undefined, 0x8ee /* getSnapshot api should be defined if used */);
+            loadedFromCache = false;
+            return this.storage.getSnapshot({
+                cacheSnapshot: false,
+                scenarioName: "snapshotForLoadingGroupId",
+                loadingGroupIds: sortedLoadingGroupIds,
+            });
+        });
+        this.logger.sendTelemetryEvent({
+            eventName: "GroupIdSnapshotFetched",
+            details: JSON.stringify({
+                fromCache: loadedFromCache,
+                loadingGroupIds: loadingGroupIds.join(","),
+            }),
+        });
+        // Find the snapshotTree inside the returned snapshot based on the path as given in the request.
+        const hasIsolatedChannels = rootHasIsolatedChannels(this.metadata);
+        const snapshotTreeForPath = this.getSnapshotTreeForPath(snapshot.snapshotTree, pathParts, hasIsolatedChannels);
+        assert(snapshotTreeForPath !== undefined, 0x8ef /* no snapshotTree for the path */);
+        const snapshotSeqNumber = snapshot.sequenceNumber;
+        assert(snapshotSeqNumber !== undefined, 0x8f0 /* snapshotSeqNumber should be present */);
+        // This assert fires if we get a snapshot older than the snapshot we loaded from. This is a service issue.
+        // Snapshots should only move forward. If we observe an older snapshot than the one we loaded from, then likely
+        // the file has been overwritten or service lost data.
+        if (snapshotSeqNumber < this.deltaManager.initialSequenceNumber) {
+            throw DataProcessingError.create("Downloaded snapshot older than snapshot we loaded from", "getSnapshotForLoadingGroupId", undefined, {
+                loadingGroupIds: sortedLoadingGroupIds.join(","),
+                snapshotSeqNumber,
+                initialSequenceNumber: this.deltaManager.initialSequenceNumber,
+            });
+        }
+        // If the snapshot is ahead of the last seq number of the delta manager, then catch up before
+        // returning the snapshot.
+        if (snapshotSeqNumber > this.deltaManager.lastSequenceNumber) {
+            // If this is a summarizer client, which is trying to load a group and it finds that there is
+            // another snapshot from which the summarizer loaded and it is behind, then just give up as
+            // the summarizer state is not up to date.
+            // This should be a recoverable scenario and shouldn't happen as we should process the ack first.
+            if (this.isSummarizerClient) {
+                throw new Error("Summarizer client behind, loaded newer snapshot with loadingGroupId");
+            }
+            // We want to catchup from sequenceNumber to targetSequenceNumber
+            const props = {
+                eventName: "GroupIdSnapshotCatchup",
+                loadingGroupIds: sortedLoadingGroupIds.join(","),
+                targetSequenceNumber: snapshotSeqNumber,
+                sequenceNumber: this.deltaManager.lastSequenceNumber, // This is so we reuse some columns in telemetry
+            };
+            const event = PerformanceEvent.start(this.mc.logger, {
+                ...props,
+            });
+            // If the inbound deltas queue is paused or disconnected, we expect a reconnect and unpause
+            // as long as it's not a summarizer client.
+            if (this.deltaManager.inbound.paused) {
+                props.inboundPaused = this.deltaManager.inbound.paused; // reusing telemetry
+            }
+            const defP = new Deferred();
+            this.deltaManager.on("op", (message) => {
+                if (message.sequenceNumber >= snapshotSeqNumber) {
+                    defP.resolve(true);
+                }
+            });
+            await defP.promise;
+            event.end(props);
+        }
+        return { snapshotTree: snapshotTreeForPath, sequenceNumber: snapshotSeqNumber };
+    }
+    /**
+     * Api to find a snapshot tree inside a bigger snapshot tree based on the path in the pathParts array.
+     * @param snapshotTree - snapshot tree to look into.
+     * @param pathParts - Part of the path, which we want to extract from the snapshot tree.
+     * @param hasIsolatedChannels - whether the channels are present inside ".channels" subtree. Older
+     * snapshots will not have trees inside ".channels", so check that.
+     * @returns - requested snapshot tree based on the path parts.
+     */
+    getSnapshotTreeForPath(snapshotTree, pathParts, hasIsolatedChannels) {
+        let childTree = snapshotTree;
+        for (const part of pathParts) {
+            if (hasIsolatedChannels) {
+                childTree = childTree?.trees[channelsTreeName];
+            }
+            childTree = childTree?.trees[part];
+        }
+        return childTree;
+    }
     /**
      * Notifies this object about the request made to the container.
      * @param request - Request made to the handler.
@@ -841,15 +1017,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                     : create404Response(request);
             }
             else if (requestParser.pathParts.length > 0) {
-                // Differentiate between requesting the dataStore directly, or one of its children
-                const requestForChild = !requestParser.isLeaf(1);
-                const dataStore = await this.getDataStoreFromRequest(id, request, requestForChild);
-                const subRequest = requestParser.createSubRequest(1);
-                // We always expect createSubRequest to include a leading slash, but asserting here to protect against
-                // unintentionally modifying the url if that changes.
-                assert(subRequest.url.startsWith("/"), 0x126 /* "Expected createSubRequest url to include a leading slash" */);
-                // eslint-disable-next-line @typescript-eslint/return-await -- Adding an await here causes test failures
-                return dataStore.request(subRequest);
+                return await this.channelCollection.request(request);
             }
             return create404Response(request);
         }
@@ -864,38 +1032,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         return this.entryPoint;
     }
     internalId(maybeAlias) {
-        return this.dataStores.aliases.get(maybeAlias) ?? maybeAlias;
-    }
-    async getDataStoreFromRequest(id, request, requestForChild) {
-        const headerData = {};
-        if (typeof request.headers?.[RuntimeHeaders.wait] === "boolean") {
-            headerData.wait = request.headers[RuntimeHeaders.wait];
-        }
-        if (typeof request.headers?.[RuntimeHeaders.viaHandle] === "boolean") {
-            headerData.viaHandle = request.headers[RuntimeHeaders.viaHandle];
-        }
-        if (typeof request.headers?.[AllowTombstoneRequestHeaderKey] === "boolean") {
-            headerData.allowTombstone = request.headers[AllowTombstoneRequestHeaderKey];
-        }
-        if (typeof request.headers?.[AllowInactiveRequestHeaderKey] === "boolean") {
-            headerData.allowInactive = request.headers[AllowInactiveRequestHeaderKey];
-        }
-        // We allow Tombstone requests for sub-DataStore objects
-        if (requestForChild) {
-            headerData.allowTombstone = true;
-        }
-        await this.dataStores.waitIfPendingAlias(id);
-        const internalId = this.internalId(id);
-        const dataStoreContext = await this.dataStores.getDataStore(internalId, headerData);
-        // Remove query params, leading and trailing slashes from the url. This is done to make sure the format is
-        // the same as GC nodes id.
-        const urlWithoutQuery = trimLeadingAndTrailingSlashes(request.url.split("?")[0]);
-        // Get the initial snapshot details which contain the data store package path.
-        const details = await dataStoreContext.getInitialSnapshotDetails();
-        // Note that this will throw if the data store is inactive or tombstoned and throwing on incorrect usage
-        // is configured.
-        this.garbageCollector.nodeUpdated(`/${urlWithoutQuery}`, "Loaded", undefined /* timestampMs */, details.pkg, request, headerData);
-        return dataStoreContext.realize();
+        return this.channelCollection.internalId(maybeAlias);
     }
     /** Adds the container's metadata to the given summary tree. */
     addMetadataToSummary(summaryTree) {
@@ -910,22 +1047,21 @@ export class ContainerRuntime extends TypedEventEmitter {
             message: extractSummaryMetadataMessage(this.deltaManager.lastMessage) ??
                 this.messageAtLastSummary,
             telemetryDocumentId: this.telemetryDocumentId,
-            idCompressorEnabled: this.idCompressorEnabled ? true : undefined,
+            idCompressorMode: this.idCompressorMode,
         };
         addBlobToSummary(summaryTree, metadataBlobName, JSON.stringify(metadata));
     }
     addContainerStateToSummary(summaryTree, fullTree, trackState, telemetryContext) {
         this.addMetadataToSummary(summaryTree);
-        if (this.idCompressorEnabled) {
-            assert(this.idCompressor !== undefined, 0x67a /* IdCompressor should be defined if enabled */);
-            const idCompressorState = JSON.stringify(this.idCompressor.serialize(false));
+        if (this._idCompressor) {
+            const idCompressorState = JSON.stringify(this._idCompressor.serialize(false));
             addBlobToSummary(summaryTree, idCompressorBlobName, idCompressorState);
         }
         if (this.remoteMessageProcessor.partialMessages.size > 0) {
             const content = JSON.stringify([...this.remoteMessageProcessor.partialMessages]);
             addBlobToSummary(summaryTree, chunksBlobName, content);
         }
-        const dataStoreAliases = this.dataStores.aliases;
+        const dataStoreAliases = this.channelCollection.aliases;
         if (dataStoreAliases.size > 0) {
             addBlobToSummary(summaryTree, aliasBlobName, JSON.stringify([...dataStoreAliases]));
         }
@@ -937,7 +1073,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         // 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) {
-            addTreeToSummary(summaryTree, blobsTreeName, blobManagerSummary);
+            addSummarizeResultToSummary(summaryTree, blobsTreeName, blobManagerSummary);
         }
         const gcSummary = this.garbageCollector.summarize(fullTree, trackState, telemetryContext);
         if (gcSummary !== undefined) {
@@ -1024,13 +1160,12 @@ export class ContainerRuntime extends TypedEventEmitter {
         const opContents = this.parseLocalOpContent(serializedOpContent);
         switch (opContents.type) {
             case ContainerMessageType.FluidDataStoreOp:
-                return this.dataStores.applyStashedOp(opContents.contents);
             case ContainerMessageType.Attach:
-                return this.dataStores.applyStashedAttachOp(opContents.contents);
+            case ContainerMessageType.Alias:
+                return this.channelCollection.applyStashedOp(opContents);
             case ContainerMessageType.IdAllocation:
-                assert(this.idCompressor !== undefined, 0x67b /* IdCompressor should be defined if enabled */);
+                assert(this.idCompressorMode !== "off", 0x8f1 /* ID compressor should be in use */);
                 return;
-            case ContainerMessageType.Alias:
             case ContainerMessageType.BlobAttach:
                 return;
             case ContainerMessageType.ChunkedOp:
@@ -1055,10 +1190,26 @@ export class ContainerRuntime extends TypedEventEmitter {
                     this.closeFn(error);
                     throw error;
                 }
+                // Note: Even if its compat behavior allows it, we don't know how to apply this stashed op.
+                // All we can do is ignore it (similar to on process).
             }
         }
     }
     setConnectionState(connected, clientId) {
+        if (connected && this.idCompressorMode === "delayed" && !this.compressorLoadInitiated) {
+            this.compressorLoadInitiated = true;
+            this.createIdCompressor()
+                .then((compressor) => {
+                this._idCompressor = compressor;
+                for (const range of this.pendingIdCompressorOps) {
+                    this._idCompressor.finalizeCreationRange(range);
+                }
+                this.pendingIdCompressorOps = [];
+            })
+                .catch((error) => {
+                this.logger.sendErrorEvent({ eventName: "IdCompressorDelayedLoad" }, error);
+            });
+        }
         if (connected === false && this.delayConnectClientId !== undefined) {
             this.delayConnectClientId = undefined;
             this.mc.logger.sendTelemetryEvent({
@@ -1122,7 +1273,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (changeOfState) {
             this.replayPendingStates();
         }
-        this.dataStores.setConnectionState(connected, clientId);
+        this.channelCollection.setConnectionState(connected, clientId);
         this.garbageCollector.setConnectionState(connected, clientId);
         raiseConnectedEvent(this.mc.logger, this, connected, clientId);
     }
@@ -1205,23 +1356,28 @@ export class ContainerRuntime extends TypedEventEmitter {
         const { local } = messageWithContext;
         switch (messageWithContext.message.type) {
             case ContainerMessageType.Attach:
-                this.dataStores.processAttachMessage(messageWithContext.message, local);
-                break;
             case ContainerMessageType.Alias:
-                this.dataStores.processAliasMessage(messageWithContext.message, localOpMetadata, local);
-                break;
             case ContainerMessageType.FluidDataStoreOp:
-                this.dataStores.processFluidDataStoreOp(messageWithContext.message, local, localOpMetadata, (from, to) => this.garbageCollector.addedOutboundReference(from, to));
+                this.channelCollection.process(messageWithContext.message, local, localOpMetadata, (from, to) => this.garbageCollector.addedOutboundReference(from, to));
                 break;
             case ContainerMessageType.BlobAttach:
                 this.blobManager.processBlobAttachOp(messageWithContext.message, local);
                 break;
             case ContainerMessageType.IdAllocation:
-                assert(this.idCompressor !== undefined, 0x67c /* IdCompressor should be defined if enabled */);
                 // Don't re-finalize the range if we're processing a "savedOp" in
                 // stashed ops flow. The compressor is stashed with these ops already processed.
-                if (messageWithContext.message.metadata?.savedOp !== true) {
-                    this.idCompressor.finalizeCreationRange(messageWithContext.message.contents);
+                // That said, in idCompressorMode === "delayed", we might not serialize ID compressor, and
+                // thus we need to process all the ops.
+                if (!(this.skipSavedCompressorOps &&
+                    messageWithContext.message.metadata?.savedOp ===
+                        true)) {
+                    const range = messageWithContext.message.contents;
+                    if (this._idCompressor === undefined) {
+                        this.pendingIdCompressorOps.push(range);
+                    }
+                    else {
+                        this._idCompressor.finalizeCreationRange(range);
+                    }
                 }
                 break;
             case ContainerMessageType.GC:
@@ -1308,7 +1464,15 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.emit("signal", transformed, local);
             return;
         }
-        this.dataStores.processSignal(envelope.address, transformed, local);
+        // Due to a mismatch between different layers in terms of
+        // what is the interface of passing signals, we need to adjust
+        // the signal envelope before sending it to the datastores to be processed
+        const envelope2 = {
+            address: envelope.address,
+            contents: transformed.content,
+        };
+        transformed.content = envelope2;
+        this.channelCollection.processSignal(transformed, local);
     }
     /**
      * Flush the pending ops manually.
@@ -1372,9 +1536,17 @@ export class ContainerRuntime extends TypedEventEmitter {
      * Returns undefined if no data store has been assigned the given alias.
      */
     async getAliasedDataStoreEntryPoint(alias) {
-        await this.dataStores.waitIfPendingAlias(alias);
+        // Back-comapatibility:
+        // There are old files that were created without using data store aliasing feature, but
+        // used createRoot*DataStore*() (already removed) API. Such data stores will have isRoot = true,
+        // and internalID provided by user. The expectation is that such files behave as new files, where
+        // same data store instances created using aliasing feature.
+        // Please also see note on name collisions in DataStores.createDataStoreId()
+        await this.channelCollection.waitIfPendingAlias(alias);
         const internalId = this.internalId(alias);
-        const context = await this.dataStores.getDataStoreIfAvailable(internalId, { wait: false });
+        const context = await this.channelCollection.getDataStoreIfAvailable(internalId, {
+            wait: false,
+        });
         // If the data store is not available or not an alias, return undefined.
         if (context === undefined || !(await context.isRoot())) {
             return undefined;
@@ -1386,28 +1558,20 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.garbageCollector.nodeUpdated(`/${internalId}`, "Loaded", undefined /* timestampMs */, context.packagePath);
         return channel.entryPoint;
     }
-    createDetachedRootDataStore(pkg, rootDataStoreId) {
-        if (rootDataStoreId.includes("/")) {
-            throw new UsageError(`Id cannot contain slashes: '${rootDataStoreId}'`);
-        }
-        return this.dataStores.createDetachedDataStoreCore(pkg, true, rootDataStoreId);
+    createDetachedDataStore(pkg, loadingGroupId) {
+        return this.channelCollection.createDetachedDataStoreCore(pkg, loadingGroupId);
     }
-    createDetachedDataStore(pkg) {
-        return this.dataStores.createDetachedDataStoreCore(pkg, false);
-    }
-    async createDataStore(pkg) {
-        const id = uuid();
-        return channelToDataStore(await this.dataStores
-            ._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id)
-            .realize(), id, this, this.dataStores, this.mc.logger);
+    async createDataStore(pkg, loadingGroupId) {
+        const context = this.channelCollection._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], undefined, // props
+        loadingGroupId);
+        return channelToDataStore(await context.realize(), context.id, this.channelCollection, this.mc.logger);
     }
     /**
      * @deprecated 0.16 Issue #1537, #3631
      */
-    async _createDataStoreWithProps(pkg, props, id = uuid()) {
-        return channelToDataStore(await this.dataStores
-            ._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id, props)
-            .realize(), id, this, this.dataStores, this.mc.logger);
+    async _createDataStoreWithProps(pkg, props) {
+        const context = this.channelCollection._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], props);
+        return channelToDataStore(await context.realize(), context.id, this.channelCollection, this.mc.logger);
     }
     canSendOps() {
         // Note that the real (non-proxy) delta manager is needed here to get the readonly info. This is because
@@ -1485,16 +1649,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         const envelope = this.createNewSignalEnvelope(undefined /* address */, type, content);
         return this.submitSignalFn(envelope, targetClientId);
     }
-    /**
-     * Submits the signal to be sent to other clients.
-     * @param type - Type of the signal.
-     * @param content - Content of the signal.
-     * @param targetClientId - When specified, the signal is only sent to the provided client id.
-     */
-    submitDataStoreSignal(address, type, content, targetClientId) {
-        const envelope = this.createNewSignalEnvelope(address, type, content);
-        return this.submitSignalFn(envelope, targetClientId);
-    }
     setAttachState(attachState) {
         if (attachState === AttachState.Attaching) {
             assert(this.attachState === AttachState.Attaching, 0x12d /* "Container Context should already be in attaching state" */);
@@ -1506,7 +1660,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (attachState === AttachState.Attached && !this.hasPendingMessages()) {
             this.updateDocumentDirtyState(false);
         }
-        this.dataStores.setAttachState(attachState);
+        this.channelCollection.setAttachState(attachState);
     }
     /**
      * Create a summary. Used when attaching or serializing a detached container.
@@ -1521,18 +1675,18 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.blobManager.setRedirectTable(blobRedirectTable);
         }
         // We can finalize any allocated IDs since we're the only client
-        const idRange = this.idCompressor?.takeNextCreationRange();
+        const idRange = this._idCompressor?.takeNextCreationRange();
         if (idRange !== undefined) {
-            this.idCompressor?.finalizeCreationRange(idRange);
+            this._idCompressor?.finalizeCreationRange(idRange);
         }
-        const summarizeResult = this.dataStores.createSummary(telemetryContext);
+        const summarizeResult = this.channelCollection.getAttachSummary(telemetryContext);
         // Wrap data store summaries in .channels subtree.
         wrapSummaryInChannelsTree(summarizeResult);
         this.addContainerStateToSummary(summarizeResult, true /* fullTree */, false /* trackState */, telemetryContext);
         return summarizeResult.summary;
     }
     async summarizeInternal(fullTree, trackState, telemetryContext) {
-        const summarizeResult = await this.dataStores.summarize(fullTree, trackState, telemetryContext);
+        const summarizeResult = await this.channelCollection.summarize(fullTree, trackState, telemetryContext);
         // Wrap data store summaries in .channels subtree.
         wrapSummaryInChannelsTree(summarizeResult);
         const pathPartsForChildren = [channelsTreeName];
@@ -1580,10 +1734,10 @@ export class ContainerRuntime extends TypedEventEmitter {
      * @see IGarbageCollectionRuntime.updateStateBeforeGC
      */
     async updateStateBeforeGC() {
-        return this.dataStores.updateStateBeforeGC();
+        return this.channelCollection.updateStateBeforeGC();
     }
     async getGCDataInternal(fullGC) {
-        return this.dataStores.getGCData(fullGC);
+        return this.channelCollection.getGCData(fullGC);
     }
     /**
      * Generates and returns the GC data for this container.
@@ -1609,7 +1763,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         // always referenced, so the used routes is only self-route (empty string).
         this.summarizerNode.updateUsedRoutes([""]);
         const { dataStoreRoutes } = this.getDataStoreAndBlobManagerRoutes(usedRoutes);
-        this.dataStores.updateUsedRoutes(dataStoreRoutes);
+        this.channelCollection.updateUsedRoutes(dataStoreRoutes);
     }
     /**
      * This is called to update objects whose routes are unused.
@@ -1618,7 +1772,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     updateUnusedRoutes(unusedRoutes) {
         const { blobManagerRoutes, dataStoreRoutes } = this.getDataStoreAndBlobManagerRoutes(unusedRoutes);
         this.blobManager.updateUnusedRoutes(blobManagerRoutes);
-        this.dataStores.updateUnusedRoutes(dataStoreRoutes);
+        this.channelCollection.updateUnusedRoutes(dataStoreRoutes);
     }
     /**
      * @deprecated Replaced by deleteSweepReadyNodes.
@@ -1633,7 +1787,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      */
     deleteSweepReadyNodes(sweepReadyRoutes) {
         const { dataStoreRoutes, blobManagerRoutes } = this.getDataStoreAndBlobManagerRoutes(sweepReadyRoutes);
-        const deletedRoutes = this.dataStores.deleteSweepReadyNodes(dataStoreRoutes);
+        const deletedRoutes = this.channelCollection.deleteSweepReadyNodes(dataStoreRoutes);
         return deletedRoutes.concat(this.blobManager.deleteSweepReadyNodes(blobManagerRoutes));
     }
     /**
@@ -1647,7 +1801,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     updateTombstonedRoutes(tombstonedRoutes) {
         const { blobManagerRoutes, dataStoreRoutes } = this.getDataStoreAndBlobManagerRoutes(tombstonedRoutes);
         this.blobManager.updateTombstonedRoutes(blobManagerRoutes);
-        this.dataStores.updateTombstonedRoutes(dataStoreRoutes);
+        this.channelCollection.updateTombstonedRoutes(dataStoreRoutes);
     }
     /**
      * Returns a server generated referenced timestamp to be used to track unreferenced nodes by GC.
@@ -1665,19 +1819,24 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (this.isBlobPath(nodePath)) {
             return GCNodeType.Blob;
         }
-        return this.dataStores.getGCNodeType(nodePath) ?? GCNodeType.Other;
+        return this.channelCollection.getGCNodeType(nodePath) ?? GCNodeType.Other;
     }
     /**
      * Called by GC to retrieve the package path of the node with the given path. The node should belong to a
      * data store or an attachment blob.
      */
     async getGCNodePackagePath(nodePath) {
+        // GC uses "/" when adding "root" references, e.g. for Aliasing or as part of Tombstone Auto-Recovery.
+        // These have no package path so return a special value.
+        if (nodePath === "/") {
+            return ["_gcRoot"];
+        }
         switch (this.getNodeType(nodePath)) {
             case GCNodeType.Blob:
                 return [BlobManager.basePath];
             case GCNodeType.DataStore:
             case GCNodeType.SubDataStore:
-                return this.dataStores.getDataStorePackagePath(nodePath);
+                return this.channelCollection.getDataStorePackagePath(nodePath);
             default:
                 assert(false, 0x2de /* "Package path requested for unsupported node type." */);
         }
@@ -1736,7 +1895,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      * @param options - options controlling how the summary is generated or submitted
      */
     async submitSummary(options) {
-        const { fullTree = false, finalAttempt = false, refreshLatestAck, summaryLogger } = options;
+        const { fullTree = false, finalAttempt = false, refreshLatestAck, summaryLogger, latestSummaryRefSeqNum, } = 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;
@@ -1748,7 +1907,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         });
         assert(this.outbox.isEmpty, 0x3d1 /* Can't trigger summary in the middle of a batch */);
         // We close the summarizer and download a new snapshot and reload the container
-        let latestSnapshotVersionId;
         if (refreshLatestAck === true) {
             return this.prefetchLatestSummaryThenClose(createChildLogger({
                 logger: summaryNumberLogger,
@@ -1790,6 +1948,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
         }
         const shouldPauseInboundSignal = this.mc.config.getBoolean("Fluid.ContainerRuntime.SubmitSummary.disableInboundSignalPause") !== true;
+        const shouldValidatePreSummaryState = this.mc.config.getBoolean("Fluid.ContainerRuntime.SubmitSummary.shouldValidatePreSummaryState") === true;
         let summaryRefSeqNum;
         try {
             await this.deltaManager.inbound.pause();
@@ -1800,7 +1959,25 @@ export class ContainerRuntime extends TypedEventEmitter {
             const minimumSequenceNumber = this.deltaManager.minimumSequenceNumber;
             const message = `Summary @${summaryRefSeqNum}:${this.deltaManager.minimumSequenceNumber}`;
             const lastAck = this.summaryCollection.latestAck;
-            this.summarizerNode.startSummary(summaryRefSeqNum, summaryNumberLogger);
+            const startSummaryResult = this.summarizerNode.startSummary(summaryRefSeqNum, summaryNumberLogger, latestSummaryRefSeqNum);
+            if (startSummaryResult.invalidNodes > 0 ||
+                startSummaryResult.mismatchNumbers.size > 0) {
+                summaryLogger.sendErrorEvent({
+                    eventName: "LatestSummaryRefSeqNumMismatch",
+                    details: {
+                        ...startSummaryResult,
+                        mismatchNumbers: Array.from(startSummaryResult.mismatchNumbers),
+                    },
+                });
+                if (shouldValidatePreSummaryState && !finalAttempt) {
+                    return {
+                        stage: "base",
+                        referenceSequenceNumber: summaryRefSeqNum,
+                        minimumSequenceNumber,
+                        error: `Summarizer node state inconsistent with summarizer state.`,
+                    };
+                }
+            }
             // Helper function to check whether we should still continue between each async step.
             const checkContinue = () => {
                 // Do not check for loss of connectivity directly! Instead leave it up to
@@ -1896,8 +2073,8 @@ export class ContainerRuntime extends TypedEventEmitter {
                 ? calculateStats(summaryTree.tree[gcTreeKey])
                 : undefined;
             const summaryStats = {
-                dataStoreCount: this.dataStores.size,
-                summarizedDataStoreCount: this.dataStores.size - handleCount,
+                dataStoreCount: this.channelCollection.size,
+                summarizedDataStoreCount: this.channelCollection.size - handleCount,
                 gcStateUpdatedDataStoreCount: this.garbageCollector.updatedDSCountSinceLastSummary,
                 gcBlobNodeCount: gcSummaryTreeStats?.blobNodeCount,
                 gcTotalBlobsSize: gcSummaryTreeStats?.totalBlobSize,
@@ -1916,34 +2093,17 @@ export class ContainerRuntime extends TypedEventEmitter {
             if (!continueResult.continue) {
                 return { stage: "generate", ...generateSummaryData, error: continueResult.error };
             }
-            // It may happen that the lastAck it not correct due to missing summaryAck in case of single commit
-            // summary. So if the previous summarizer closes just after submitting the summary and before
-            // submitting the summaryOp then we can't rely on summaryAck. So in case we have
-            // 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?.summaryAck.contents.handle !== latestSnapshotVersionId &&
-                latestSnapshotVersionId !== undefined) {
-                summaryContext = {
-                    proposalHandle: undefined,
-                    ackHandle: latestSnapshotVersionId,
-                    referenceSequenceNumber: summaryRefSeqNum,
-                };
-            }
-            else if (lastAck === undefined) {
-                summaryContext = {
+            const summaryContext = lastAck === undefined
+                ? {
                     proposalHandle: undefined,
                     ackHandle: this.loadedFromVersionId,
                     referenceSequenceNumber: summaryRefSeqNum,
-                };
-            }
-            else {
-                summaryContext = {
+                }
+                : {
                     proposalHandle: lastAck.summaryOp.contents.handle,
                     ackHandle: lastAck.summaryAck.contents.handle,
                     referenceSequenceNumber: summaryRefSeqNum,
                 };
-            }
             let handle;
             try {
                 handle = await this.storage.uploadSummaryWithContext(summarizeResult.summary, summaryContext);
@@ -2068,48 +2228,29 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.emit(dirty ? "dirty" : "saved");
         }
     }
-    submitDataStoreOp(id, contents, localOpMetadata = undefined) {
-        const envelope = {
-            address: id,
-            contents,
-        };
-        this.submit({ type: ContainerMessageType.FluidDataStoreOp, contents: envelope }, localOpMetadata);
-    }
-    submitDataStoreAliasOp(contents, localOpMetadata) {
-        const aliasMessage = contents;
-        if (!isDataStoreAliasMessage(aliasMessage)) {
-            throw new UsageError("malformedDataStoreAliasMessage");
-        }
-        this.submit({ type: ContainerMessageType.Alias, contents }, localOpMetadata);
+    submitMessage(type, contents, localOpMetadata = undefined) {
+        this.submit({ type, contents }, localOpMetadata);
     }
     async uploadBlob(blob, signal) {
         this.verifyNotClosed();
         return this.blobManager.createBlob(blob, signal);
     }
-    maybeSubmitIdAllocationOp(type) {
-        if (type !== ContainerMessageType.IdAllocation) {
-            let idAllocationBatchMessage;
-            let idRange;
-            if (this.idCompressorEnabled) {
-                assert(this.idCompressor !== undefined, 0x67d /* IdCompressor should be defined if enabled */);
-                idRange = this.idCompressor.takeNextCreationRange();
-                // Don't include the idRange if there weren't any Ids allocated
-                idRange = idRange?.ids !== undefined ? idRange : undefined;
-            }
-            if (idRange !== undefined) {
+    submitIdAllocationOpIfNeeded() {
+        if (this._idCompressor) {
+            const idRange = this._idCompressor.takeNextCreationRange();
+            // Don't include the idRange if there weren't any Ids allocated
+            if (idRange?.ids !== undefined) {
                 const idAllocationMessage = {
                     type: ContainerMessageType.IdAllocation,
                     contents: idRange,
                 };
-                idAllocationBatchMessage = {
+                const idAllocationBatchMessage = {
                     contents: JSON.stringify(idAllocationMessage),
                     referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
                     metadata: undefined,
                     localOpMetadata: undefined,
                     type: ContainerMessageType.IdAllocation,
                 };
-            }
-            if (idAllocationBatchMessage !== undefined) {
                 this.outbox.submitIdAllocation(idAllocationBatchMessage);
             }
         }
@@ -2137,42 +2278,47 @@ export class ContainerRuntime extends TypedEventEmitter {
             referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
         };
         try {
-            // Submit an IdAllocation op if any Ids have been generated since
-            // the last op was submitted. Don't submit another if it's an IdAllocation
-            // op as that means we're in resubmission flow and we don't want to send
-            // IdRanges out of order.
-            this.maybeSubmitIdAllocationOp(type);
-            // If this is attach message for new data store, and we are in a batch, send this op out of order
-            // Is it safe:
-            //    Yes, this should be safe reordering. Newly created data stores are not visible through API surface.
-            //    They become visible only when aliased, or handle to some sub-element of newly created datastore
-            //    is stored in some DDS, i.e. only after some other op.
-            // Why:
-            //    Attach ops are large, and expensive to process. Plus there are scenarios where a lot of new data
-            //    stores are created, causing issues like relay service throttling (too many ops) and catastrophic
-            //    failure (batch is too large). Pushing them earlier and outside of main batch should alleviate
-            //    these issues.
-            // Cons:
-            //    1. With large batches, relay service may throttle clients. Clients may disconnect while throttled.
-            //    This change creates new possibility of a lot of newly created data stores never being referenced
-            //    because client died before it had a change to submit the rest of the ops. This will create more
-            //    garbage that needs to be collected leveraging GC (Garbage Collection) feature.
-            //    2. Sending ops out of order means they are excluded from rollback functionality. This is not an issue
-            //    today as rollback can't undo creation of data store. To some extent not sending them is a bigger
-            //    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.disableAttachReorder !== true) {
-                this.outbox.submitAttach(message);
-            }
-            else if (type === ContainerMessageType.BlobAttach) {
-                // BlobAttach ops must have their metadata visible and cannot be grouped (see opGroupingManager.ts)
-                this.outbox.submitBlobAttach(message);
+            // If `message` is an allocation op, then we are in the resubmit path and we must redirect the allocation
+            // op into the correct batch to avoid ranges being finalized out of order.
+            // Otherwise, submit an IdAllocation op if any IDs have been generated since the last op was submitted, as
+            // any of the other op types may contain those IDs and thus depend on the allocation op being sent first.
+            if (type === ContainerMessageType.IdAllocation) {
+                this.outbox.submitIdAllocation(message);
             }
             else {
-                this.outbox.submit(message);
+                this.submitIdAllocationOpIfNeeded();
+                // If this is attach message for new data store, and we are in a batch, send this op out of order
+                // Is it safe:
+                //    Yes, this should be safe reordering. Newly created data stores are not visible through API surface.
+                //    They become visible only when aliased, or handle to some sub-element of newly created datastore
+                //    is stored in some DDS, i.e. only after some other op.
+                // Why:
+                //    Attach ops are large, and expensive to process. Plus there are scenarios where a lot of new data
+                //    stores are created, causing issues like relay service throttling (too many ops) and catastrophic
+                //    failure (batch is too large). Pushing them earlier and outside of main batch should alleviate
+                //    these issues.
+                // Cons:
+                //    1. With large batches, relay service may throttle clients. Clients may disconnect while throttled.
+                //    This change creates new possibility of a lot of newly created data stores never being referenced
+                //    because client died before it had a change to submit the rest of the ops. This will create more
+                //    garbage that needs to be collected leveraging GC (Garbage Collection) feature.
+                //    2. Sending ops out of order means they are excluded from rollback functionality. This is not an issue
+                //    today as rollback can't undo creation of data store. To some extent not sending them is a bigger
+                //    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.disableAttachReorder !== true) {
+                    this.outbox.submitAttach(message);
+                }
+                else if (type === ContainerMessageType.BlobAttach) {
+                    // BlobAttach ops must have their metadata visible and cannot be grouped (see opGroupingManager.ts)
+                    this.outbox.submitBlobAttach(message);
+                }
+                else {
+                    this.outbox.submit(message);
+                }
             }
             if (!this.currentlyBatching()) {
                 this.flush();
@@ -2288,14 +2434,15 @@ export class ContainerRuntime extends TypedEventEmitter {
      * @param localOpMetadata - The local metadata associated with the original message.
      */
     reSubmitCore(message, localOpMetadata, opMetadata) {
+        assert(!this.isSummarizerClient, 0x8f2 /* Summarizer never reconnects so should never resubmit */);
         switch (message.type) {
             case ContainerMessageType.FluidDataStoreOp:
+            case ContainerMessageType.Attach:
+            case ContainerMessageType.Alias:
                 // For Operations, call resubmitDataStoreOp which will find the right store
                 // and trigger resubmission on it.
-                this.dataStores.resubmitDataStoreOp(message.contents, localOpMetadata);
+                this.channelCollection.reSubmit(message.type, message.contents, localOpMetadata);
                 break;
-            case ContainerMessageType.Attach:
-            case ContainerMessageType.Alias:
             case ContainerMessageType.IdAllocation: {
                 this.submit(message, localOpMetadata);
                 break;
@@ -2309,13 +2456,14 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.submit(message);
                 break;
             case ContainerMessageType.GC:
-                // GC op is only sent in summarizer which should never reconnect.
-                throw new LoggingError("GC op not expected to be resubmitted in summarizer");
+                this.submit(message);
+                break;
             default: {
                 // This case should be very rare - it would imply an op was stashed from a
-                // future version of runtime code and now is being applied on an older version
+                // future version of runtime code and now is being applied on an older version.
                 const compatBehavior = message.compatDetails?.behavior;
                 if (compatBehaviorAllowsMessageType(message.type, compatBehavior)) {
+                    // We do not ultimately resubmit it, to be consistent with this version of the code.
                     this.logger.sendTelemetryEvent({
                         eventName: "resubmitUnrecognizedMessageTypeAllowed",
                         messageDetails: { type: message.type, compatBehavior },
@@ -2341,7 +2489,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             case ContainerMessageType.FluidDataStoreOp:
                 // For operations, call rollbackDataStoreOp which will find the right store
                 // and trigger rollback on it.
-                this.dataStores.rollbackDataStoreOp(contents, localOpMetadata);
+                this.channelCollection.rollback(type, contents, localOpMetadata);
                 break;
             default:
                 // Don't check message.compatDetails because this is for rolling back a local op so the type will be known
@@ -2362,31 +2510,12 @@ export class ContainerRuntime extends TypedEventEmitter {
          * and then close as the current main client is likely to be re-elected as the parent summarizer again.
          */
         if (!result.isSummaryTracked && result.isSummaryNewer) {
-            const fetchResult = await this.fetchLatestSnapshotFromStorage(summaryLogger, {
+            await this.fetchLatestSnapshotFromStorage(summaryLogger, {
                 eventName: "RefreshLatestSummaryAckFetch",
                 ackHandle,
                 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.
-             * However, there are couple of scenarios where it's possible:
-             * 1. A file was modified externally resulting in modifying the snapshot's sequence number. This can lead to
-             * the document being unusable and we should not proceed.
-             * 2. The server DB failed after the ack was sent which may delete the corresponding snapshot. Ideally, in
-             * such cases, the file will be rolled back along with the ack and we will eventually reach a consistent
-             * state.
-             */
-            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.disposeFn(error);
-                throw error;
-            }
-            await this.closeStaleSummarizer("RefreshLatestSummaryAckFetch");
+            await this.closeStaleSummarizer();
             return;
         }
         // Notify the garbage collector so it can update its latest summary state.
@@ -2405,7 +2534,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         await this.fetchLatestSnapshotFromStorage(summaryLogger, {
             eventName: "RefreshLatestSummaryFromServerFetch",
         }, readAndParseBlob);
-        await this.closeStaleSummarizer("RefreshLatestSummaryFromServerFetch");
+        await this.closeStaleSummarizer();
         return {
             stage: "base",
             error: "summary state stale - Unsupported option 'refreshLatestAck'",
@@ -2413,7 +2542,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             minimumSequenceNumber: this.deltaManager.minimumSequenceNumber,
         };
     }
-    async closeStaleSummarizer(codePath) {
+    async closeStaleSummarizer() {
         // Delay before restarting summarizer to prevent the summarizer from restarting too frequently.
         await delay(this.closeSummarizerDelayMs);
         this._summarizer?.stop("latestSummaryStateStale");
@@ -2445,44 +2574,43 @@ export class ContainerRuntime extends TypedEventEmitter {
             };
         });
     }
-    async getPendingLocalState(props) {
-        return PerformanceEvent.timedExecAsync(this.mc.logger, {
-            eventName: "getPendingLocalState",
-            notifyImminentClosure: props?.notifyImminentClosure,
-        }, async (event) => {
-            this.verifyNotClosed();
-            // in case imminentClosure is set to true by future code, we don't
-            // try to change its value
-            if (!this.imminentClosure) {
-                this.imminentClosure = props?.notifyImminentClosure ?? this.imminentClosure;
-            }
-            const stopBlobAttachingSignal = props?.stopBlobAttachingSignal;
-            if (this._orderSequentiallyCalls !== 0) {
-                throw new UsageError("can't get state during orderSequentially");
-            }
-            // Flush pending batch.
-            // getPendingLocalState() is only exposed through Container.closeAndGetPendingLocalState(), so it's safe
-            // to close current batch.
-            this.flush();
-            const pendingAttachmentBlobs = this.imminentClosure
-                ? await this.blobManager.attachAndGetPendingBlobs(stopBlobAttachingSignal)
-                : undefined;
+    getPendingLocalState(props) {
+        this.verifyNotClosed();
+        if (this._orderSequentiallyCalls !== 0) {
+            throw new UsageError("can't get state during orderSequentially");
+        }
+        this.imminentClosure || (this.imminentClosure = props?.notifyImminentClosure ?? false);
+        const getSyncState = (pendingAttachmentBlobs) => {
             const pending = this.pendingStateManager.getLocalState();
-            if (!pendingAttachmentBlobs && !this.hasPendingMessages()) {
+            if (pendingAttachmentBlobs === undefined && !this.hasPendingMessages()) {
                 return; // no pending state to save
             }
-            const pendingIdCompressorState = this.idCompressor?.serialize(true);
-            const pendingState = {
+            const pendingIdCompressorState = this._idCompressor?.serialize(true);
+            return {
                 pending,
-                pendingAttachmentBlobs,
                 pendingIdCompressorState,
+                pendingAttachmentBlobs,
+                sessionExpiryTimerStarted: this.garbageCollector.sessionExpiryTimerStarted,
             };
+        };
+        const perfEvent = {
+            eventName: "getPendingLocalState",
+            notifyImminentClosure: props?.notifyImminentClosure,
+        };
+        const logAndReturnPendingState = (event, pendingState) => {
             event.end({
-                attachmentBlobsSize: Object.keys(pendingAttachmentBlobs ?? {}).length,
-                pendingOpsSize: pending?.pendingStates.length,
+                attachmentBlobsSize: Object.keys(pendingState?.pendingAttachmentBlobs ?? {}).length,
+                pendingOpsSize: pendingState?.pending?.pendingStates.length,
             });
             return pendingState;
-        });
+        };
+        // Flush pending batch.
+        // getPendingLocalState() is only exposed through Container.closeAndGetPendingLocalState(), so it's safe
+        // to close current batch.
+        this.flush();
+        return props?.notifyImminentClosure === true
+            ? PerformanceEvent.timedExecAsync(this.mc.logger, perfEvent, async (event) => logAndReturnPendingState(event, getSyncState(await this.blobManager.attachAndGetPendingBlobs(props?.stopBlobAttachingSignal))))
+            : PerformanceEvent.timedExec(this.mc.logger, perfEvent, (event) => logAndReturnPendingState(event, getSyncState()));
     }
     summarizeOnDemand(options) {
         if (this.isSummarizerClient) {
@@ -2536,4 +2664,4 @@ export class ContainerRuntime extends TypedEventEmitter {
         return killSwitch !== true && this.runtimeOptions.enableGroupedBatching;
     }
 }
-//# sourceMappingURL=containerRuntime.mjs.map
+//# sourceMappingURL=containerRuntime.js.map