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

package/dist/containerRuntime.js

@@ -1,6 +1,10 @@
 "use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContainerRuntime = exports.makeLegacySendBatchFn = exports.getDeviceSpec = exports.agentSchedulerId = exports.isRuntimeMessage = exports.RuntimeMessage = exports.defaultPendingOpsRetryDelayMs = exports.defaultPendingOpsWaitTimeoutMs = exports.CompressionAlgorithms = exports.defaultRuntimeHeaderData = exports.InactiveResponseHeaderKey = exports.TombstoneResponseHeaderKey = exports.AllowInactiveRequestHeaderKey = exports.AllowTombstoneRequestHeaderKey = exports.RuntimeHeaders = exports.DefaultSummaryConfiguration = void 0;
+exports.ContainerRuntime = exports.makeLegacySendBatchFn = exports.getDeviceSpec = exports.agentSchedulerId = exports.isRuntimeMessage = exports.RuntimeMessage = exports.defaultPendingOpsRetryDelayMs = exports.defaultPendingOpsWaitTimeoutMs = exports.CompressionAlgorithms = exports.defaultRuntimeHeaderData = exports.InactiveResponseHeaderKey = exports.TombstoneResponseHeaderKey = exports.DefaultSummaryConfiguration = void 0;
 const container_definitions_1 = require("@fluidframework/container-definitions");
 const core_utils_1 = require("@fluidframework/core-utils");
 const client_utils_1 = require("@fluid-internal/client-utils");
@@ -11,22 +15,22 @@ const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const runtime_definitions_1 = require("@fluidframework/runtime-definitions");
 const runtime_utils_1 = require("@fluidframework/runtime-utils");
 const uuid_1 = require("uuid");
-const containerHandleContext_1 = require("./containerHandleContext");
-const dataStoreRegistry_1 = require("./dataStoreRegistry");
-const connectionTelemetry_1 = require("./connectionTelemetry");
-const pendingStateManager_1 = require("./pendingStateManager");
-const packageVersion_1 = require("./packageVersion");
-const blobManager_1 = require("./blobManager");
-const dataStores_1 = require("./dataStores");
-const summary_1 = require("./summary");
-const throttler_1 = require("./throttler");
-const gc_1 = require("./gc");
-const dataStore_1 = require("./dataStore");
-const batchTracker_1 = require("./batchTracker");
-const scheduleManager_1 = require("./scheduleManager");
-const opLifecycle_1 = require("./opLifecycle");
-const deltaManagerSummarizerProxy_1 = require("./deltaManagerSummarizerProxy");
-const messageTypes_1 = require("./messageTypes");
+const containerHandleContext_js_1 = require("./containerHandleContext.js");
+const dataStoreRegistry_js_1 = require("./dataStoreRegistry.js");
+const connectionTelemetry_js_1 = require("./connectionTelemetry.js");
+const pendingStateManager_js_1 = require("./pendingStateManager.js");
+const packageVersion_js_1 = require("./packageVersion.js");
+const blobManager_js_1 = require("./blobManager.js");
+const channelCollection_js_1 = require("./channelCollection.js");
+const index_js_1 = require("./summary/index.js");
+const throttler_js_1 = require("./throttler.js");
+const index_js_2 = require("./gc/index.js");
+const dataStore_js_1 = require("./dataStore.js");
+const batchTracker_js_1 = require("./batchTracker.js");
+const scheduleManager_js_1 = require("./scheduleManager.js");
+const index_js_3 = require("./opLifecycle/index.js");
+const deltaManagerSummarizerProxy_js_1 = require("./deltaManagerSummarizerProxy.js");
+const messageTypes_js_1 = require("./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
@@ -56,26 +60,6 @@ exports.DefaultSummaryConfiguration = {
     runtimeOpWeight: 1.0,
     nonRuntimeHeuristicThreshold: 20,
 };
-/**
- * Accepted header keys for requests coming to the runtime.
- * @internal
- */
-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 || (exports.RuntimeHeaders = RuntimeHeaders = {}));
-/** True if a tombstoned object should be returned without erroring
- * @alpha
- */
-exports.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
- */
-exports.AllowInactiveRequestHeaderKey = "allowInactive"; // Belongs in the enum above, but avoiding the breaking change
 /**
  * Tombstone error responses will have this header set to true
  * @alpha
@@ -192,7 +176,7 @@ async function createSummarizer(loader, url) {
             [container_definitions_1.LoaderHeader.cache]: false,
             [container_definitions_1.LoaderHeader.clientDetails]: {
                 capabilities: { interactive: false },
-                type: summary_1.summarizerClientType,
+                type: index_js_1.summarizerClientType,
             },
             [driver_definitions_1.DriverHeader.summarizingClient]: true,
             [container_definitions_1.LoaderHeader.reconnect]: false,
@@ -247,18 +231,18 @@ class ContainerRuntime extends client_utils_1.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 telemetry_utils_1.TaggedLoggerAdapter(backCompatContext.logger);
         const logger = (0, telemetry_utils_1.createChildLogger)({
             logger: passLogger,
             properties: {
                 all: {
-                    runtimeVersion: packageVersion_1.pkgVersion,
+                    runtimeVersion: packageVersion_js_1.pkgVersion,
                 },
             },
         });
-        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, compressionOptions = defaultCompressionConfig, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, enableRuntimeIdCompressor = false, chunkSizeInBytes = defaultChunkSizeInBytes, enableOpReentryCheck = false, enableGroupedBatching = false, } = runtimeOptions;
-        const registry = new dataStoreRegistry_1.FluidDataStoreRegistry(registryEntries);
+        const mc = (0, telemetry_utils_1.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 dataStoreRegistry_js_1.FluidDataStoreRegistry(registryEntries);
         const tryFetchBlob = async (blobName) => {
             const blobId = context.baseSnapshot?.blobs[blobName];
             if (context.baseSnapshot && blobId) {
@@ -269,14 +253,14 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             }
         };
         const [chunks, metadata, electedSummarizerData, aliases, serializedIdCompressor] = await Promise.all([
-            tryFetchBlob(summary_1.chunksBlobName),
-            tryFetchBlob(summary_1.metadataBlobName),
-            tryFetchBlob(summary_1.electedSummarizerBlobName),
-            tryFetchBlob(summary_1.aliasBlobName),
-            tryFetchBlob(summary_1.idCompressorBlobName),
+            tryFetchBlob(index_js_1.chunksBlobName),
+            tryFetchBlob(index_js_1.metadataBlobName),
+            tryFetchBlob(index_js_1.electedSummarizerBlobName),
+            tryFetchBlob(index_js_1.aliasBlobName),
+            tryFetchBlob(index_js_1.idCompressorBlobName),
         ]);
         // read snapshot blobs needed for BlobManager to load
-        const blobManagerSnapshot = await blobManager_1.BlobManager.load(context.baseSnapshot?.trees[summary_1.blobsTreeName], async (id) => {
+        const blobManagerSnapshot = await blobManager_js_1.BlobManager.load(context.baseSnapshot?.trees[index_js_1.blobsTreeName], async (id) => {
             // IContainerContext storage api return type still has undefined in 0.39 package version.
             // So once we release 0.40 container-defn package we can remove this check.
             (0, core_utils_1.assert)(context.storage !== undefined, 0x256 /* "storage undefined in attached container" */);
@@ -293,7 +277,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 // "Load from summary, runtime metadata sequenceNumber !== initialSequenceNumber"
                 const error = new telemetry_utils_1.DataCorruptionError(
                 // pre-0.58 error message: SummaryMetadataMismatch
-                "Summary metadata mismatch", { runtimeVersion: packageVersion_1.pkgVersion, runtimeSequenceNumber, protocolSequenceNumber });
+                "Summary metadata mismatch", { runtimeVersion: packageVersion_js_1.pkgVersion, runtimeSequenceNumber, protocolSequenceNumber });
                 if (loadSequenceNumberVerification === "log") {
                     logger.sendErrorEvent({ eventName: "SequenceNumberMismatch" }, error);
                 }
@@ -302,9 +286,37 @@ class ContainerRuntime extends client_utils_1.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
@@ -321,15 +333,15 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             const compressorLogger = (0, telemetry_utils_1.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,
@@ -341,7 +353,7 @@ class ContainerRuntime extends client_utils_1.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);
@@ -355,6 +367,9 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     get storage() {
         return this._storage;
     }
+    get containerRuntime() {
+        return this;
+    }
     get flushMode() {
         return this._flushMode;
     }
@@ -367,6 +382,25 @@ class ContainerRuntime extends client_utils_1.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") {
+            (0, core_utils_1.assert)(this._idCompressor !== undefined, 0x8ea /* compressor should have been loaded */);
+            return this._idCompressor;
+        }
+    }
+    /**
+     * See IContainerRuntimeBase.generateDocumentUniqueId() for details.
+     */
+    generateDocumentUniqueId() {
+        return this._idCompressor?.generateDocumentUniqueId() ?? (0, uuid_1.v4)();
+    }
     get IFluidHandleContext() {
         return this.handleContext;
     }
@@ -404,9 +438,6 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     isSummariesDisabled() {
         return this.summaryConfiguration.state === "disabled";
     }
-    isHeuristicsDisabled() {
-        return this.summaryConfiguration.state === "disableHeuristics";
-    }
     getMaxOpsSinceLastSummary() {
         return this.summaryConfiguration.state !== "disabled"
             ? this.summaryConfiguration.maxOpsSinceLastSummary
@@ -431,7 +462,7 @@ class ContainerRuntime extends client_utils_1.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
         ...exports.DefaultSummaryConfiguration,
         // the runtime configuration overrides
@@ -439,13 +470,24 @@ class ContainerRuntime extends client_utils_1.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;
@@ -467,18 +509,27 @@ class ContainerRuntime extends client_utils_1.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 core_utils_1.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_1.DeltaManagerSummarizerProxy(this.innerDeltaManager);
+        this.deltaManager = new deltaManagerSummarizerProxy_js_1.DeltaManagerSummarizerProxy(this.innerDeltaManager);
         // Here we could wrap/intercept on these functions to block/modify outgoing messages if needed.
         // This makes ContainerRuntime the final gatekeeper for outgoing messages.
         this.submitFn = submitFn;
         this.submitBatchFn = submitBatchFn;
         this.submitSummaryFn = submitSummaryFn;
         this.submitSignalFn = submitSignalFn;
-        this.options = options;
+        // 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 === summary_1.summarizerClientType;
+        this.isSummarizerClient = this.clientDetails.type === index_js_1.summarizerClientType;
         this.loadedFromVersionId = context.getLoadedFromVersion()?.id;
         this._getClientId = () => context.clientId;
         this._getAttachState = () => context.attachState;
@@ -514,19 +565,13 @@ class ContainerRuntime extends client_utils_1.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 = {
-                createContainerRuntimeVersion: packageVersion_1.pkgVersion,
+                createContainerRuntimeVersion: packageVersion_js_1.pkgVersion,
                 createContainerTimestamp: Date.now(),
             };
             loadSummaryNumber = 0;
-            this.idCompressorEnabled =
-                this.mc.config.getBoolean("Fluid.ContainerRuntime.IdCompressorEnabled") ??
-                    idCompressor !== undefined;
         }
         this.nextSummaryNumber = loadSummaryNumber + 1;
         this.messageAtLastSummary = metadata?.message;
@@ -537,21 +582,21 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             eventName: "GCFeatureMatrix",
             metadataValue: JSON.stringify(metadata?.gcFeatureMatrix),
             inputs: JSON.stringify({
-                gcOptions_gcGeneration: this.runtimeOptions.gcOptions[gc_1.gcGenerationOptionName],
+                gcOptions_gcGeneration: this.runtimeOptions.gcOptions[index_js_2.gcGenerationOptionName],
             }),
         });
         this.telemetryDocumentId = metadata?.telemetryDocumentId ?? (0, uuid_1.v4)();
         this.disableAttachReorder = this.mc.config.getBoolean("Fluid.ContainerRuntime.disableAttachOpReorder");
         const disableChunking = this.mc.config.getBoolean("Fluid.ContainerRuntime.CompressionChunkingDisabled");
-        const opGroupingManager = new opLifecycle_1.OpGroupingManager({
+        const opGroupingManager = new index_js_3.OpGroupingManager({
             groupedBatchingEnabled: this.groupedBatchingEnabled,
             opCountThreshold: this.mc.config.getNumber("Fluid.ContainerRuntime.GroupedBatchingOpCount") ?? 2,
             reentrantBatchGroupingEnabled: this.mc.config.getBoolean("Fluid.ContainerRuntime.GroupedBatchingReentrancy") ??
                 true,
         }, this.mc.logger);
-        const opSplitter = new opLifecycle_1.OpSplitter(chunks, this.submitBatchFn, disableChunking === true ? Number.POSITIVE_INFINITY : runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger);
-        this.remoteMessageProcessor = new opLifecycle_1.RemoteMessageProcessor(opSplitter, new opLifecycle_1.OpDecompressor(this.mc.logger), opGroupingManager);
-        this.handleContext = new containerHandleContext_1.ContainerFluidHandleContext("", this);
+        const opSplitter = new index_js_3.OpSplitter(chunks, this.submitBatchFn, disableChunking === true ? Number.POSITIVE_INFINITY : runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger);
+        this.remoteMessageProcessor = new index_js_3.RemoteMessageProcessor(opSplitter, new index_js_3.OpDecompressor(this.mc.logger), opGroupingManager);
+        this.handleContext = new containerHandleContext_js_1.ContainerFluidHandleContext("", this);
         if (this.summaryConfiguration.state === "enabled") {
             this.validateSummaryHeuristicConfiguration(this.summaryConfiguration);
         }
@@ -561,12 +606,8 @@ class ContainerRuntime extends client_utils_1.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;
@@ -590,7 +631,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 throw new telemetry_utils_1.UsageError("Driver's maximumCacheDurationMs policy cannot exceed 5 days");
             }
         }
-        this.garbageCollector = gc_1.GarbageCollector.create({
+        this.garbageCollector = index_js_2.GarbageCollector.create({
             runtime: this,
             gcOptions: this.runtimeOptions.gcOptions,
             baseSnapshot,
@@ -603,9 +644,10 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             getLastSummaryTimestampMs: () => this.messageAtLastSummary?.timestamp,
             readAndParseBlob: async (id) => (0, driver_utils_1.readAndParse)(this.storage, id),
             submitMessage: (message) => this.submit(message),
+            sessionExpiryTimerStarted: pendingRuntimeState?.sessionExpiryTimerStarted,
         });
         const loadedFromSequenceNumber = this.deltaManager.initialSequenceNumber;
-        this.summarizerNode = (0, summary_1.createRootSummarizerNodeWithGC)((0, telemetry_utils_1.createChildLogger)({ logger: this.logger, namespace: "SummarizerNode" }), 
+        this.summarizerNode = (0, index_js_1.createRootSummarizerNodeWithGC)((0, telemetry_utils_1.createChildLogger)({ logger: this.logger, namespace: "SummarizerNode" }), 
         // Summarize function to call when summarize is called. Summarizer node always tracks summary state.
         async (fullTree, trackState, telemetryContext) => this.summarizeInternal(fullTree, trackState, telemetryContext), 
         // Latest change sequence number, no changes since summary applied yet
@@ -625,24 +667,37 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         if (baseSnapshot) {
             this.summarizerNode.updateBaseSummaryState(baseSnapshot);
         }
-        this.dataStores = new dataStores_1.DataStores((0, dataStores_1.getSummaryForDatastores)(baseSnapshot, metadata), this, (attachMsg) => this.submit({ type: messageTypes_1.ContainerMessageType.Attach, contents: attachMsg }), (id, createParam) => (summarizeInternal, getGCDataFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), (path) => this.garbageCollector.isNodeDeleted(path), new Map(dataStoreAliasMap));
-        this.blobManager = new blobManager_1.BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (localId, blobId) => {
+        const parentContext = (0, channelCollection_js_1.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_js_1.ChannelCollection((0, channelCollection_js_1.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_js_1.BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (localId, blobId) => {
             if (!this.disposed) {
-                this.submit({ type: messageTypes_1.ContainerMessageType.BlobAttach, contents: undefined }, undefined, {
+                this.submit({ type: messageTypes_js_1.ContainerMessageType.BlobAttach, contents: undefined }, undefined, {
                     localId,
                     blobId,
                 });
             }
         }, (blobPath) => this.garbageCollector.nodeUpdated(blobPath, "Loaded"), (blobPath) => this.garbageCollector.isNodeDeleted(blobPath), this, pendingRuntimeState?.pendingAttachmentBlobs, (error) => this.closeFn(error));
-        this.scheduleManager = new scheduleManager_1.ScheduleManager(this.innerDeltaManager, this, () => this.clientId, (0, telemetry_utils_1.createChildLogger)({ logger: this.logger, namespace: "ScheduleManager" }));
-        this.pendingStateManager = new pendingStateManager_1.PendingStateManager({
+        this.scheduleManager = new scheduleManager_js_1.ScheduleManager(this.innerDeltaManager, this, () => this.clientId, (0, telemetry_utils_1.createChildLogger)({ logger: this.logger, namespace: "ScheduleManager" }));
+        this.pendingStateManager = new pendingStateManager_js_1.PendingStateManager({
             applyStashedOp: this.applyStashedOp.bind(this),
             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 !== container_definitions_1.AttachState.Detached,
         }, pendingRuntimeState?.pending, this.logger);
         const disableCompression = this.mc.config.getBoolean("Fluid.ContainerRuntime.CompressionDisabled");
         const compressionOptions = disableCompression === true
@@ -653,12 +708,12 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             : runtimeOptions.compressionOptions;
         const disablePartialFlush = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisablePartialFlush");
         const legacySendBatchFn = (0, exports.makeLegacySendBatchFn)(this.submitFn, this.innerDeltaManager);
-        this.outbox = new opLifecycle_1.Outbox({
+        this.outbox = new index_js_3.Outbox({
             shouldSend: () => this.canSendOps(),
             pendingStateManager: this.pendingStateManager,
             submitBatchFn: this.submitBatchFn,
             legacySendBatchFn,
-            compressor: new opLifecycle_1.OpCompressor(this.mc.logger),
+            compressor: new index_js_3.OpCompressor(this.mc.logger),
             splitter: opSplitter,
             config: {
                 compressionOptions,
@@ -685,7 +740,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         this.closeSummarizerDelayMs = closeSummarizerDelayOverride ?? defaultCloseSummarizerDelayMs;
         this.validateSummaryBeforeUpload =
             this.mc.config.getBoolean("Fluid.Summarizer.ValidateSummaryBeforeUpload") ?? false;
-        this.summaryCollection = new summary_1.SummaryCollection(this.deltaManager, this.logger);
+        this.summaryCollection = new index_js_1.SummaryCollection(this.deltaManager, this.logger);
         this.dirtyContainer =
             this.attachState !== container_definitions_1.AttachState.Attached || this.hasPendingMessages();
         context.updateDirtyContainerState(this.dirtyContainer);
@@ -697,16 +752,16 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 logger: this.logger,
                 namespace: "OrderedClientElection",
             });
-            const orderedClientCollection = new summary_1.OrderedClientCollection(orderedClientLogger, this.innerDeltaManager, this._quorum);
-            const orderedClientElectionForSummarizer = new summary_1.OrderedClientElection(orderedClientLogger, orderedClientCollection, electedSummarizerData ?? this.innerDeltaManager.lastSequenceNumber, summary_1.SummarizerClientElection.isClientEligible);
-            this.summarizerClientElection = new summary_1.SummarizerClientElection(orderedClientLogger, this.summaryCollection, orderedClientElectionForSummarizer, this.maxOpsSinceLastSummary);
+            const orderedClientCollection = new index_js_1.OrderedClientCollection(orderedClientLogger, this.innerDeltaManager, this._quorum);
+            const orderedClientElectionForSummarizer = new index_js_1.OrderedClientElection(orderedClientLogger, orderedClientCollection, electedSummarizerData ?? this.innerDeltaManager.lastSequenceNumber, index_js_1.SummarizerClientElection.isClientEligible);
+            this.summarizerClientElection = new index_js_1.SummarizerClientElection(orderedClientLogger, this.summaryCollection, orderedClientElectionForSummarizer, this.maxOpsSinceLastSummary);
             if (this.isSummarizerClient) {
-                this._summarizer = new summary_1.Summarizer(this /* ISummarizerRuntime */, () => this.summaryConfiguration, this /* ISummarizerInternalsProvider */, this.handleContext, this.summaryCollection, async (runtime) => summary_1.RunWhileConnectedCoordinator.create(runtime, 
+                this._summarizer = new index_js_1.Summarizer(this /* ISummarizerRuntime */, () => this.summaryConfiguration, this /* ISummarizerInternalsProvider */, this.handleContext, this.summaryCollection, async (runtime) => index_js_1.RunWhileConnectedCoordinator.create(runtime, 
                 // Summarization runs in summarizer client and needs access to the real (non-proxy) active
                 // information. The proxy delta manager would always return false for summarizer client.
                 () => this.innerDeltaManager.active));
             }
-            else if (summary_1.SummarizerClientElection.clientDetailsPermitElection(this.clientDetails)) {
+            else if (index_js_1.SummarizerClientElection.clientDetailsPermitElection(this.clientDetails)) {
                 // Only create a SummaryManager and SummarizerClientElection
                 // if summaries are enabled and we are not the summarizer client.
                 const defaultAction = () => {
@@ -728,13 +783,13 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 };
                 this.summaryCollection.on("default", defaultAction);
                 // Create the SummaryManager and mark the initial state
-                this.summaryManager = new summary_1.SummaryManager(this.summarizerClientElection, this, // IConnectedState
-                this.summaryCollection, this.logger, this.formCreateSummarizerFn(loader), new throttler_1.Throttler(60 * 1000, // 60 sec delay window
+                this.summaryManager = new index_js_1.SummaryManager(this.summarizerClientElection, this, // IConnectedState
+                this.summaryCollection, this.logger, this.formCreateSummarizerFn(loader), new throttler_js_1.Throttler(60 * 1000, // 60 sec delay window
                 30 * 1000, // 30 sec max delay
                 // throttling function increases exponentially (0ms, 40ms, 80ms, 160ms, etc)
-                (0, throttler_1.formExponentialFn)({ coefficient: 20, initialDelay: 0 })), {
+                (0, throttler_js_1.formExponentialFn)({ coefficient: 20, initialDelay: 0 })), {
                     initialDelayMs: this.initialSummarizerDelayMs,
-                }, this.heuristicsDisabled);
+                });
                 this.summaryManager.on("summarize", (eventProps) => {
                     this.emit("summarize", eventProps);
                 });
@@ -749,26 +804,27 @@ class ContainerRuntime extends client_utils_1.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,
         });
-        (0, connectionTelemetry_1.ReportOpPerfTelemetry)(this.clientId, this.deltaManager, this.logger);
-        (0, batchTracker_1.BindBatchTracker)(this, this.logger);
+        (0, connectionTelemetry_js_1.ReportOpPerfTelemetry)(this.clientId, this.deltaManager, this, this.logger);
+        (0, batchTracker_js_1.BindBatchTracker)(this, this.logger);
         this.entryPoint = new core_utils_1.LazyPromise(async () => {
             if (this.isSummarizerClient) {
                 (0, core_utils_1.assert)(this._summarizer !== undefined, 0x5bf /* Summarizer object is undefined in a summarizer client */);
@@ -776,11 +832,33 @@ class ContainerRuntime extends client_utils_1.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() {
+        (0, core_utils_1.assert)(false, 0x8eb /* should not be called */);
+    }
+    setChannelDirty(address) {
+        (0, core_utils_1.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.
+            (0, core_utils_1.assert)(this.pendingIdCompressorOps.length === 0, 0x8ec /* no pending ops */);
+            this._idCompressor = await this.createIdCompressor();
+        }
         await this.garbageCollector.initializeBaseState();
     }
     dispose(error) {
@@ -799,11 +877,110 @@ class ContainerRuntime extends client_utils_1.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();
+        (0, core_utils_1.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 () => {
+            (0, core_utils_1.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 = (0, index_js_1.rootHasIsolatedChannels)(this.metadata);
+        const snapshotTreeForPath = this.getSnapshotTreeForPath(snapshot.snapshotTree, pathParts, hasIsolatedChannels);
+        (0, core_utils_1.assert)(snapshotTreeForPath !== undefined, 0x8ef /* no snapshotTree for the path */);
+        const snapshotSeqNumber = snapshot.sequenceNumber;
+        (0, core_utils_1.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 telemetry_utils_1.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 = telemetry_utils_1.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 core_utils_1.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[runtime_definitions_1.channelsTreeName];
+            }
+            childTree = childTree?.trees[part];
+        }
+        return childTree;
+    }
     /**
      * Notifies this object about the request made to the container.
      * @param request - Request made to the handler.
@@ -846,7 +1023,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 // eslint-disable-next-line @typescript-eslint/return-await -- Adding an await here causes test failures
                 return this.resolveHandle(requestParser.createSubRequest(1));
             }
-            if (id === blobManager_1.BlobManager.basePath && requestParser.isLeaf(2)) {
+            if (id === blobManager_js_1.BlobManager.basePath && requestParser.isLeaf(2)) {
                 const blob = await this.blobManager.getBlob(requestParser.pathParts[1]);
                 return blob
                     ? {
@@ -857,15 +1034,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                     : (0, runtime_utils_1.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.
-                (0, core_utils_1.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 (0, runtime_utils_1.create404Response)(request);
         }
@@ -880,38 +1049,7 @@ class ContainerRuntime extends client_utils_1.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?.[exports.AllowTombstoneRequestHeaderKey] === "boolean") {
-            headerData.allowTombstone = request.headers[exports.AllowTombstoneRequestHeaderKey];
-        }
-        if (typeof request.headers?.[exports.AllowInactiveRequestHeaderKey] === "boolean") {
-            headerData.allowInactive = request.headers[exports.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 = (0, gc_1.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) {
@@ -923,37 +1061,36 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             ...this.garbageCollector.getMetadata(),
             // The last message processed at the time of summary. If there are no new messages, use the message from the
             // last summary.
-            message: (0, summary_1.extractSummaryMetadataMessage)(this.deltaManager.lastMessage) ??
+            message: (0, index_js_1.extractSummaryMetadataMessage)(this.deltaManager.lastMessage) ??
                 this.messageAtLastSummary,
             telemetryDocumentId: this.telemetryDocumentId,
-            idCompressorEnabled: this.idCompressorEnabled ? true : undefined,
+            idCompressorMode: this.idCompressorMode,
         };
-        (0, runtime_utils_1.addBlobToSummary)(summaryTree, summary_1.metadataBlobName, JSON.stringify(metadata));
+        (0, runtime_utils_1.addBlobToSummary)(summaryTree, index_js_1.metadataBlobName, JSON.stringify(metadata));
     }
     addContainerStateToSummary(summaryTree, fullTree, trackState, telemetryContext) {
         this.addMetadataToSummary(summaryTree);
-        if (this.idCompressorEnabled) {
-            (0, core_utils_1.assert)(this.idCompressor !== undefined, 0x67a /* IdCompressor should be defined if enabled */);
-            const idCompressorState = JSON.stringify(this.idCompressor.serialize(false));
-            (0, runtime_utils_1.addBlobToSummary)(summaryTree, summary_1.idCompressorBlobName, idCompressorState);
+        if (this._idCompressor) {
+            const idCompressorState = JSON.stringify(this._idCompressor.serialize(false));
+            (0, runtime_utils_1.addBlobToSummary)(summaryTree, index_js_1.idCompressorBlobName, idCompressorState);
         }
         if (this.remoteMessageProcessor.partialMessages.size > 0) {
             const content = JSON.stringify([...this.remoteMessageProcessor.partialMessages]);
-            (0, runtime_utils_1.addBlobToSummary)(summaryTree, summary_1.chunksBlobName, content);
+            (0, runtime_utils_1.addBlobToSummary)(summaryTree, index_js_1.chunksBlobName, content);
         }
-        const dataStoreAliases = this.dataStores.aliases;
+        const dataStoreAliases = this.channelCollection.aliases;
         if (dataStoreAliases.size > 0) {
-            (0, runtime_utils_1.addBlobToSummary)(summaryTree, summary_1.aliasBlobName, JSON.stringify([...dataStoreAliases]));
+            (0, runtime_utils_1.addBlobToSummary)(summaryTree, index_js_1.aliasBlobName, JSON.stringify([...dataStoreAliases]));
         }
         if (this.summarizerClientElection) {
             const electedSummarizerContent = JSON.stringify(this.summarizerClientElection?.serialize());
-            (0, runtime_utils_1.addBlobToSummary)(summaryTree, summary_1.electedSummarizerBlobName, electedSummarizerContent);
+            (0, runtime_utils_1.addBlobToSummary)(summaryTree, index_js_1.electedSummarizerBlobName, electedSummarizerContent);
         }
         const blobManagerSummary = this.blobManager.summarize();
         // Some storage (like git) doesn't allow empty tree, so we can omit it.
         // and the blob manager can handle the tree not existing when loading
         if (Object.keys(blobManagerSummary.summary.tree).length > 0) {
-            (0, runtime_utils_1.addTreeToSummary)(summaryTree, summary_1.blobsTreeName, blobManagerSummary);
+            (0, runtime_utils_1.addSummarizeResultToSummary)(summaryTree, index_js_1.blobsTreeName, blobManagerSummary);
         }
         const gcSummary = this.garbageCollector.summarize(fullTree, trackState, telemetryContext);
         if (gcSummary !== undefined) {
@@ -988,14 +1125,8 @@ class ContainerRuntime extends client_utils_1.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 !== messageTypes_1.ContainerMessageType.ChunkedOp) {
-            this.consecutiveReconnects = 0;
-        }
+    resetReconnectCount() {
+        this.consecutiveReconnects = 0;
     }
     replayPendingStates() {
         // We need to be able to send ops to replay states
@@ -1039,21 +1170,20 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // Need to parse from string for back-compat
         const opContents = this.parseLocalOpContent(serializedOpContent);
         switch (opContents.type) {
-            case messageTypes_1.ContainerMessageType.FluidDataStoreOp:
-                return this.dataStores.applyStashedOp(opContents.contents);
-            case messageTypes_1.ContainerMessageType.Attach:
-                return this.dataStores.applyStashedAttachOp(opContents.contents);
-            case messageTypes_1.ContainerMessageType.IdAllocation:
-                (0, core_utils_1.assert)(this.idCompressor !== undefined, 0x67b /* IdCompressor should be defined if enabled */);
+            case messageTypes_js_1.ContainerMessageType.FluidDataStoreOp:
+            case messageTypes_js_1.ContainerMessageType.Attach:
+            case messageTypes_js_1.ContainerMessageType.Alias:
+                return this.channelCollection.applyStashedOp(opContents);
+            case messageTypes_js_1.ContainerMessageType.IdAllocation:
+                (0, core_utils_1.assert)(this.idCompressorMode !== "off", 0x8f1 /* ID compressor should be in use */);
                 return;
-            case messageTypes_1.ContainerMessageType.Alias:
-            case messageTypes_1.ContainerMessageType.BlobAttach:
+            case messageTypes_js_1.ContainerMessageType.BlobAttach:
                 return;
-            case messageTypes_1.ContainerMessageType.ChunkedOp:
+            case messageTypes_js_1.ContainerMessageType.ChunkedOp:
                 throw new Error("chunkedOp not expected here");
-            case messageTypes_1.ContainerMessageType.Rejoin:
+            case messageTypes_js_1.ContainerMessageType.Rejoin:
                 throw new Error("rejoin not expected here");
-            case messageTypes_1.ContainerMessageType.GC:
+            case messageTypes_js_1.ContainerMessageType.GC:
                 // GC op is only sent in summarizer which should never have stashed ops.
                 throw new telemetry_utils_1.LoggingError("GC op not expected to be stashed in summarizer");
             default: {
@@ -1077,6 +1207,20 @@ class ContainerRuntime extends client_utils_1.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({
@@ -1140,7 +1284,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         if (changeOfState) {
             this.replayPendingStates();
         }
-        this.dataStores.setConnectionState(connected, clientId);
+        this.channelCollection.setConnectionState(connected, clientId);
         this.garbageCollector.setConnectionState(connected, clientId);
         (0, telemetry_utils_1.raiseConnectedEvent)(this.mc.logger, this, connected, clientId);
     }
@@ -1187,10 +1331,13 @@ class ContainerRuntime extends client_utils_1.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
+            (0, core_utils_1.assert)(message.type !== messageTypes_js_1.ContainerMessageType.ChunkedOp, "we should never get here with chunked ops");
             let localOpMetadata;
-            if (local &&
-                messageWithContext.modernRuntimeMessage &&
-                message.type !== messageTypes_1.ContainerMessageType.ChunkedOp) {
+            if (local && messageWithContext.modernRuntimeMessage) {
                 localOpMetadata = this.pendingStateManager.processPendingLocalMessage(messageWithContext.message);
             }
             // If there are no more pending messages after processing a local message,
@@ -1205,7 +1352,7 @@ class ContainerRuntime extends client_utils_1.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) {
@@ -1222,31 +1369,39 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // TODO: destructure message and modernRuntimeMessage once using typescript 5.2.2+
         const { local } = messageWithContext;
         switch (messageWithContext.message.type) {
-            case messageTypes_1.ContainerMessageType.Attach:
-                this.dataStores.processAttachMessage(messageWithContext.message, local);
-                break;
-            case messageTypes_1.ContainerMessageType.Alias:
-                this.dataStores.processAliasMessage(messageWithContext.message, localOpMetadata, local);
+            case messageTypes_js_1.ContainerMessageType.Attach:
+            case messageTypes_js_1.ContainerMessageType.Alias:
+            case messageTypes_js_1.ContainerMessageType.FluidDataStoreOp:
+                this.channelCollection.process(messageWithContext.message, local, localOpMetadata, (from, to) => this.garbageCollector.addedOutboundReference(from, to));
                 break;
-            case messageTypes_1.ContainerMessageType.FluidDataStoreOp:
-                this.dataStores.processFluidDataStoreOp(messageWithContext.message, local, localOpMetadata, (from, to) => this.garbageCollector.addedOutboundReference(from, to));
-                break;
-            case messageTypes_1.ContainerMessageType.BlobAttach:
+            case messageTypes_js_1.ContainerMessageType.BlobAttach:
                 this.blobManager.processBlobAttachOp(messageWithContext.message, local);
                 break;
-            case messageTypes_1.ContainerMessageType.IdAllocation:
-                (0, core_utils_1.assert)(this.idCompressor !== undefined, 0x67c /* IdCompressor should be defined if enabled */);
+            case messageTypes_js_1.ContainerMessageType.IdAllocation:
                 // 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 messageTypes_1.ContainerMessageType.GC:
+            case messageTypes_js_1.ContainerMessageType.GC:
                 this.garbageCollector.processMessage(messageWithContext.message, local);
                 break;
-            case messageTypes_1.ContainerMessageType.ChunkedOp:
-            case messageTypes_1.ContainerMessageType.Rejoin:
+            case messageTypes_js_1.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.
+                (0, core_utils_1.assert)(false, "should not even get here");
+            case messageTypes_js_1.ContainerMessageType.Rejoin:
                 break;
             default: {
                 // If we didn't necessarily expect a runtime message type, then no worries - just return
@@ -1326,7 +1481,15 @@ class ContainerRuntime extends client_utils_1.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.
@@ -1390,9 +1553,17 @@ class ContainerRuntime extends client_utils_1.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;
@@ -1404,28 +1575,20 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         this.garbageCollector.nodeUpdated(`/${internalId}`, "Loaded", undefined /* timestampMs */, context.packagePath);
         return channel.entryPoint;
     }
-    createDetachedRootDataStore(pkg, rootDataStoreId) {
-        if (rootDataStoreId.includes("/")) {
-            throw new telemetry_utils_1.UsageError(`Id cannot contain slashes: '${rootDataStoreId}'`);
-        }
-        return this.dataStores.createDetachedDataStoreCore(pkg, true, rootDataStoreId);
+    createDetachedDataStore(pkg, loadingGroupId) {
+        return this.channelCollection.createDetachedDataStore(pkg, loadingGroupId);
     }
-    createDetachedDataStore(pkg, groupId) {
-        return this.dataStores.createDetachedDataStoreCore(pkg, false, undefined, groupId);
-    }
-    async createDataStore(pkg, groupId) {
-        const id = (0, uuid_1.v4)();
-        return (0, dataStore_1.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 (0, dataStore_js_1.channelToDataStore)(await context.realize(), context.id, this.channelCollection, this.mc.logger);
     }
     /**
      * @deprecated 0.16 Issue #1537, #3631
      */
-    async _createDataStoreWithProps(pkg, props, id = (0, uuid_1.v4)()) {
-        return (0, dataStore_1.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 (0, dataStore_js_1.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
@@ -1455,21 +1618,22 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // Certain container runtime messages should not mark the container dirty such as the old built-in
         // AgentScheduler and Garbage collector messages.
         switch (type) {
-            case messageTypes_1.ContainerMessageType.Attach: {
+            case messageTypes_js_1.ContainerMessageType.Attach: {
                 const attachMessage = contents;
                 if (attachMessage.id === exports.agentSchedulerId) {
                     return false;
                 }
                 break;
             }
-            case messageTypes_1.ContainerMessageType.FluidDataStoreOp: {
+            case messageTypes_js_1.ContainerMessageType.FluidDataStoreOp: {
                 const envelope = contents;
                 if (envelope.address === exports.agentSchedulerId) {
                     return false;
                 }
                 break;
             }
-            case messageTypes_1.ContainerMessageType.GC: {
+            case messageTypes_js_1.ContainerMessageType.IdAllocation:
+            case messageTypes_js_1.ContainerMessageType.GC: {
                 return false;
             }
             default:
@@ -1503,16 +1667,6 @@ class ContainerRuntime extends client_utils_1.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 === container_definitions_1.AttachState.Attaching) {
             (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attaching, 0x12d /* "Container Context should already be in attaching state" */);
@@ -1524,7 +1678,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         if (attachState === container_definitions_1.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.
@@ -1539,20 +1693,20 @@ class ContainerRuntime extends client_utils_1.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.
-        (0, summary_1.wrapSummaryInChannelsTree)(summarizeResult);
+        (0, index_js_1.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.
-        (0, summary_1.wrapSummaryInChannelsTree)(summarizeResult);
+        (0, index_js_1.wrapSummaryInChannelsTree)(summarizeResult);
         const pathPartsForChildren = [runtime_definitions_1.channelsTreeName];
         this.addContainerStateToSummary(summarizeResult, fullTree, trackState, telemetryContext);
         return {
@@ -1598,10 +1752,10 @@ class ContainerRuntime extends client_utils_1.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.
@@ -1627,22 +1781,7 @@ class ContainerRuntime extends client_utils_1.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.
@@ -1651,7 +1790,7 @@ class ContainerRuntime extends client_utils_1.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));
     }
     /**
@@ -1665,7 +1804,7 @@ class ContainerRuntime extends client_utils_1.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.
@@ -1681,9 +1820,9 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      */
     getNodeType(nodePath) {
         if (this.isBlobPath(nodePath)) {
-            return gc_1.GCNodeType.Blob;
+            return index_js_2.GCNodeType.Blob;
         }
-        return this.dataStores.getGCNodeType(nodePath) ?? gc_1.GCNodeType.Other;
+        return this.channelCollection.getGCNodeType(nodePath) ?? index_js_2.GCNodeType.Other;
     }
     /**
      * Called by GC to retrieve the package path of the node with the given path. The node should belong to a
@@ -1693,14 +1832,14 @@ class ContainerRuntime extends client_utils_1.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 gc_1.GCNodeType.Blob:
-                return [blobManager_1.BlobManager.basePath];
-            case gc_1.GCNodeType.DataStore:
-            case gc_1.GCNodeType.SubDataStore:
-                return this.dataStores.getDataStorePackagePath(nodePath);
+            case index_js_2.GCNodeType.Blob:
+                return [blobManager_js_1.BlobManager.basePath];
+            case index_js_2.GCNodeType.DataStore:
+            case index_js_2.GCNodeType.SubDataStore:
+                return this.channelCollection.getDataStorePackagePath(nodePath);
             default:
                 (0, core_utils_1.assert)(false, 0x2de /* "Package path requested for unsupported node type." */);
         }
@@ -1710,7 +1849,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      */
     isBlobPath(path) {
         const pathParts = path.split("/");
-        if (pathParts.length < 2 || pathParts[1] !== blobManager_1.BlobManager.basePath) {
+        if (pathParts.length < 2 || pathParts[1] !== blobManager_js_1.BlobManager.basePath) {
             return false;
         }
         return true;
@@ -1759,7 +1898,7 @@ class ContainerRuntime extends client_utils_1.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;
@@ -1812,6 +1951,7 @@ class ContainerRuntime extends client_utils_1.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();
@@ -1822,7 +1962,25 @@ class ContainerRuntime extends client_utils_1.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
@@ -1892,7 +2050,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 const validateResult = this.summarizerNode.validateSummary();
                 if (!validateResult.success) {
                     const { success, ...loggingProps } = validateResult;
-                    const error = new summary_1.RetriableSummaryError(validateResult.reason, validateResult.retryAfterSeconds, { ...loggingProps });
+                    const error = new index_js_1.RetriableSummaryError(validateResult.reason, validateResult.retryAfterSeconds, { ...loggingProps });
                     return {
                         stage: "base",
                         referenceSequenceNumber: summaryRefSeqNum,
@@ -1918,8 +2076,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 ? (0, runtime_utils_1.calculateStats)(summaryTree.tree[runtime_definitions_1.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,
@@ -2039,7 +2197,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             // based on telemetry while we decide on a stable number.
             const retryDelayMs = this.mc.config.getNumber("Fluid.Summarizer.PendingOpsRetryDelayMs") ??
                 exports.defaultPendingOpsRetryDelayMs;
-            const error = new summary_1.RetriableSummaryError("PendingOpsWhileSummarizing", retryDelayMs / 1000, {
+            const error = new index_js_1.RetriableSummaryError("PendingOpsWhileSummarizing", retryDelayMs / 1000, {
                 count: this.pendingMessagesCount,
                 beforeGenerate: beforeSummaryGeneration,
             });
@@ -2073,48 +2231,29 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             this.emit(dirty ? "dirty" : "saved");
         }
     }
-    submitDataStoreOp(id, contents, localOpMetadata = undefined) {
-        const envelope = {
-            address: id,
-            contents,
-        };
-        this.submit({ type: messageTypes_1.ContainerMessageType.FluidDataStoreOp, contents: envelope }, localOpMetadata);
-    }
-    submitDataStoreAliasOp(contents, localOpMetadata) {
-        const aliasMessage = contents;
-        if (!(0, dataStore_1.isDataStoreAliasMessage)(aliasMessage)) {
-            throw new telemetry_utils_1.UsageError("malformedDataStoreAliasMessage");
-        }
-        this.submit({ type: messageTypes_1.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 !== messageTypes_1.ContainerMessageType.IdAllocation) {
-            let idAllocationBatchMessage;
-            let idRange;
-            if (this.idCompressorEnabled) {
-                (0, core_utils_1.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: messageTypes_1.ContainerMessageType.IdAllocation,
+                    type: messageTypes_js_1.ContainerMessageType.IdAllocation,
                     contents: idRange,
                 };
-                idAllocationBatchMessage = {
+                const idAllocationBatchMessage = {
                     contents: JSON.stringify(idAllocationMessage),
                     referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
                     metadata: undefined,
                     localOpMetadata: undefined,
-                    type: messageTypes_1.ContainerMessageType.IdAllocation,
+                    type: messageTypes_js_1.ContainerMessageType.IdAllocation,
                 };
-            }
-            if (idAllocationBatchMessage !== undefined) {
                 this.outbox.submitIdAllocation(idAllocationBatchMessage);
             }
         }
@@ -2142,42 +2281,47 @@ class ContainerRuntime extends client_utils_1.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 === messageTypes_1.ContainerMessageType.Attach &&
-                this.disableAttachReorder !== true) {
-                this.outbox.submitAttach(message);
-            }
-            else if (type === messageTypes_1.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 === messageTypes_js_1.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 === messageTypes_js_1.ContainerMessageType.Attach &&
+                    this.disableAttachReorder !== true) {
+                    this.outbox.submitAttach(message);
+                }
+                else if (type === messageTypes_js_1.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();
@@ -2252,7 +2396,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             if (this.opReentryCallsToReport > 0) {
                 this.mc.logger.sendTelemetryEvent({ eventName: "OpReentry" }, 
                 // We need to capture the call stack in order to inspect the source of this usage pattern
-                (0, opLifecycle_1.getLongStack)(() => new telemetry_utils_1.UsageError(errorMessage)));
+                (0, index_js_3.getLongStack)(() => new telemetry_utils_1.UsageError(errorMessage)));
                 this.opReentryCallsToReport--;
             }
             // Creating ops while processing ops can lead
@@ -2293,28 +2437,28 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      * @param localOpMetadata - The local metadata associated with the original message.
      */
     reSubmitCore(message, localOpMetadata, opMetadata) {
-        (0, core_utils_1.assert)(!this.isSummarizerClient, "Summarizer never reconnects so should never resubmit");
+        (0, core_utils_1.assert)(!this.isSummarizerClient, 0x8f2 /* Summarizer never reconnects so should never resubmit */);
         switch (message.type) {
-            case messageTypes_1.ContainerMessageType.FluidDataStoreOp:
+            case messageTypes_js_1.ContainerMessageType.FluidDataStoreOp:
+            case messageTypes_js_1.ContainerMessageType.Attach:
+            case messageTypes_js_1.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 messageTypes_1.ContainerMessageType.Attach:
-            case messageTypes_1.ContainerMessageType.Alias:
-            case messageTypes_1.ContainerMessageType.IdAllocation: {
+            case messageTypes_js_1.ContainerMessageType.IdAllocation: {
                 this.submit(message, localOpMetadata);
                 break;
             }
-            case messageTypes_1.ContainerMessageType.ChunkedOp:
+            case messageTypes_js_1.ContainerMessageType.ChunkedOp:
                 throw new Error(`chunkedOp not expected here`);
-            case messageTypes_1.ContainerMessageType.BlobAttach:
+            case messageTypes_js_1.ContainerMessageType.BlobAttach:
                 this.blobManager.reSubmit(opMetadata);
                 break;
-            case messageTypes_1.ContainerMessageType.Rejoin:
+            case messageTypes_js_1.ContainerMessageType.Rejoin:
                 this.submit(message);
                 break;
-            case messageTypes_1.ContainerMessageType.GC:
+            case messageTypes_js_1.ContainerMessageType.GC:
                 this.submit(message);
                 break;
             default: {
@@ -2345,10 +2489,10 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // Need to parse from string for back-compat
         const { type, contents } = this.parseLocalOpContent(content);
         switch (type) {
-            case messageTypes_1.ContainerMessageType.FluidDataStoreOp:
+            case messageTypes_js_1.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
@@ -2433,44 +2577,43 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             };
         });
     }
-    async getPendingLocalState(props) {
-        return telemetry_utils_1.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 telemetry_utils_1.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 telemetry_utils_1.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
+            ? telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, perfEvent, async (event) => logAndReturnPendingState(event, getSyncState(await this.blobManager.attachAndGetPendingBlobs(props?.stopBlobAttachingSignal))))
+            : telemetry_utils_1.PerformanceEvent.timedExec(this.mc.logger, perfEvent, (event) => logAndReturnPendingState(event, getSyncState()));
     }
     summarizeOnDemand(options) {
         if (this.isSummarizerClient) {