@fluidframework/container-runtime 2.0.0-dev-rc.1.0.0.232845 → 2.0.0-dev-rc.2.0.0.246488

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

@@ -1,31 +1,33 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
 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, createSampledLogger, } 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 +57,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 +225,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 +234,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,9 +280,37 @@ 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
@@ -317,15 +327,15 @@ export class ContainerRuntime extends TypedEventEmitter {
             const compressorLogger = createSampledLogger(logger, idCompressorEventSampler);
             const pendingLocalState = context.pendingLocalState;
             if (pendingLocalState?.pendingIdCompressorState !== undefined) {
-                idCompressor = deserializeIdCompressor(pendingLocalState.pendingIdCompressorState, compressorLogger);
+                return deserializeIdCompressor(pendingLocalState.pendingIdCompressorState, compressorLogger);
             }
             else if (serializedIdCompressor !== undefined) {
-                idCompressor = deserializeIdCompressor(serializedIdCompressor, createSessionId(), compressorLogger);
+                return deserializeIdCompressor(serializedIdCompressor, createSessionId(), compressorLogger);
             }
             else {
-                idCompressor = createIdCompressor(compressorLogger);
+                return createIdCompressor(compressorLogger);
             }
-        }
+        };
         const runtime = new containerRuntimeCtor(context, registry, metadata, electedSummarizerData, chunks ?? [], aliases ?? [], {
             summaryOptions,
             gcOptions,
@@ -337,7 +347,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);
@@ -351,6 +361,9 @@ export class ContainerRuntime extends TypedEventEmitter {
     get storage() {
         return this._storage;
     }
+    get containerRuntime() {
+        return this;
+    }
     get flushMode() {
         return this._flushMode;
     }
@@ -363,6 +376,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;
     }
@@ -400,9 +432,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
@@ -427,7 +456,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
@@ -435,13 +464,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;
@@ -463,6 +503,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);
@@ -472,7 +519,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;
@@ -510,9 +559,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 = {
@@ -520,9 +566,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;
@@ -557,12 +600,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;
@@ -599,6 +638,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" }), 
@@ -621,7 +661,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, {
@@ -636,9 +685,13 @@ export class ContainerRuntime extends TypedEventEmitter {
             clientId: () => this.clientId,
             close: this.closeFn,
             connected: () => this.connected,
-            reSubmit: this.reSubmit.bind(this),
+            reSubmit: (message) => {
+                this.reSubmit(message);
+                this.flush();
+            },
             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
@@ -730,7 +783,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);
                 });
@@ -745,25 +798,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) {
@@ -772,11 +826,33 @@ 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);
+    }
+    /* IFluidParentContext APIs that should not be called on Root */
+    makeLocallyVisible() {
+        assert(false, 0x8eb /* should not be called */);
+    }
+    setChannelDirty(address) {
+        assert(false, 0x909 /* 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) {
@@ -795,11 +871,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.
@@ -853,15 +1028,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);
         }
@@ -876,38 +1043,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) {
@@ -922,22 +1058,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]));
         }
@@ -949,7 +1084,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) {
@@ -984,14 +1119,8 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         return this.consecutiveReconnects < this.maxConsecutiveReconnects;
     }
-    resetReconnectCount(message) {
-        // Chunked ops don't count towards making progress as they are sent
-        // in their own batches before the originating batch is sent.
-        // Therefore, receiving them while attempting to send the originating batch
-        // does not mean that the container is making any progress.
-        if (message?.type !== ContainerMessageType.ChunkedOp) {
-            this.consecutiveReconnects = 0;
-        }
+    resetReconnectCount() {
+        this.consecutiveReconnects = 0;
     }
     replayPendingStates() {
         // We need to be able to send ops to replay states
@@ -1036,13 +1165,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:
@@ -1073,6 +1201,20 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
     }
     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({
@@ -1136,7 +1278,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);
     }
@@ -1183,10 +1325,13 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.scheduleManager.beforeOpProcessing(message);
         this._processedClientSequenceNumber = message.clientSequenceNumber;
         try {
+            // See commit that added this assert for more details.
+            // These calls should be made for all but chunked ops:
+            // 1) this.pendingStateManager.processPendingLocalMessage() below
+            // 2) this.resetReconnectCount() below
+            assert(message.type !== ContainerMessageType.ChunkedOp, "we should never get here with chunked ops");
             let localOpMetadata;
-            if (local &&
-                messageWithContext.modernRuntimeMessage &&
-                message.type !== ContainerMessageType.ChunkedOp) {
+            if (local && messageWithContext.modernRuntimeMessage) {
                 localOpMetadata = this.pendingStateManager.processPendingLocalMessage(messageWithContext.message);
             }
             // If there are no more pending messages after processing a local message,
@@ -1201,7 +1346,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // If we have processed a local op, this means that the container is
                 // making progress and we can reset the counter for how many times
                 // we have consecutively replayed the pending states
-                this.resetReconnectCount(message);
+                this.resetReconnectCount();
             }
         }
         catch (e) {
@@ -1219,29 +1364,37 @@ 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:
                 this.garbageCollector.processMessage(messageWithContext.message, local);
                 break;
             case ContainerMessageType.ChunkedOp:
+                // From observability POV, we should not exppse the rest of the system (including "op" events on object) to these messages.
+                // Also resetReconnectCount() would be wrong - see comment that was there before this change was made.
+                assert(false, "should not even get here");
             case ContainerMessageType.Rejoin:
                 break;
             default: {
@@ -1322,7 +1475,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.
@@ -1386,9 +1547,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;
@@ -1400,28 +1569,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, groupId) {
-        return this.dataStores.createDetachedDataStoreCore(pkg, false, undefined, groupId);
+    createDetachedDataStore(pkg, loadingGroupId) {
+        return this.channelCollection.createDetachedDataStore(pkg, loadingGroupId);
     }
-    async createDataStore(pkg, groupId) {
-        const id = uuid();
-        return channelToDataStore(await this.dataStores
-            ._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id, undefined, groupId)
-            .realize(), id, this, this.dataStores, this.mc.logger);
+    async createDataStore(pkg, loadingGroupId) {
+        const context = this.channelCollection.createDataStoreContext(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.createDataStoreContext(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
@@ -1465,6 +1626,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 }
                 break;
             }
+            case ContainerMessageType.IdAllocation:
             case ContainerMessageType.GC: {
                 return false;
             }
@@ -1499,16 +1661,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" */);
@@ -1520,7 +1672,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.
@@ -1535,18 +1687,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];
@@ -1594,10 +1746,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.
@@ -1623,22 +1775,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 is called to update objects whose routes are unused.
-     * @param unusedRoutes - Data store and attachment blob routes that are unused in this Container.
-     */
-    updateUnusedRoutes(unusedRoutes) {
-        const { blobManagerRoutes, dataStoreRoutes } = this.getDataStoreAndBlobManagerRoutes(unusedRoutes);
-        this.blobManager.updateUnusedRoutes(blobManagerRoutes);
-        this.dataStores.updateUnusedRoutes(dataStoreRoutes);
-    }
-    /**
-     * @deprecated Replaced by deleteSweepReadyNodes.
-     */
-    deleteUnusedNodes(unusedRoutes) {
-        throw new Error("deleteUnusedRoutes should not be called");
+        this.channelCollection.updateUsedRoutes(dataStoreRoutes);
     }
     /**
      * After GC has run and identified nodes that are sweep ready, this is called to delete the sweep ready nodes.
@@ -1647,7 +1784,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));
     }
     /**
@@ -1661,7 +1798,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.
@@ -1679,7 +1816,7 @@ 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
@@ -1689,14 +1826,14 @@ export class ContainerRuntime extends TypedEventEmitter {
         // 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>"];
+            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." */);
         }
@@ -1755,7 +1892,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;
@@ -1808,6 +1945,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();
@@ -1818,7 +1956,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
@@ -1914,8 +2070,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,
@@ -2069,48 +2225,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);
             }
         }
@@ -2138,42 +2275,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();
@@ -2289,15 +2431,15 @@ export class ContainerRuntime extends TypedEventEmitter {
      * @param localOpMetadata - The local metadata associated with the original message.
      */
     reSubmitCore(message, localOpMetadata, opMetadata) {
-        assert(!this.isSummarizerClient, "Summarizer never reconnects so should never resubmit");
+        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;
@@ -2344,7 +2486,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
@@ -2429,44 +2571,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) {
@@ -2520,4 +2661,4 @@ export class ContainerRuntime extends TypedEventEmitter {
         return killSwitch !== true && this.runtimeOptions.enableGroupedBatching;
     }
 }
-//# sourceMappingURL=containerRuntime.mjs.map
+//# sourceMappingURL=containerRuntime.js.map