@fluidframework/container-runtime 2.13.0 → 2.21.0

package/lib/containerRuntime.js

@@ -2,7 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { Trace, TypedEventEmitter } from "@fluid-internal/client-utils";
+import { Trace, TypedEventEmitter, } from "@fluid-internal/client-utils";
 import { AttachState, } from "@fluidframework/container-definitions";
 import { LoaderHeader, isIDeltaManagerFull, } from "@fluidframework/container-definitions/internal";
 import { assert, Deferred, LazyPromise, PromiseCache, delay, } from "@fluidframework/core-utils/internal";
@@ -23,13 +23,21 @@ import { ContainerFluidHandleContext } from "./containerHandleContext.js";
 import { channelToDataStore } from "./dataStore.js";
 import { FluidDataStoreRegistry } from "./dataStoreRegistry.js";
 import { DeltaManagerPendingOpsProxy, DeltaManagerSummarizerProxy, } from "./deltaManagerProxies.js";
-import { GCNodeType, GarbageCollector, gcGenerationOptionName, } from "./gc/index.js";
+import { DeltaScheduler } from "./deltaScheduler.js";
+import { 
+// eslint-disable-next-line import/no-deprecated
+GCNodeType, GarbageCollector, gcGenerationOptionName, } from "./gc/index.js";
+import { InboundBatchAggregator } from "./inboundBatchAggregator.js";
+import { RuntimeCompatDetails, validateLoaderCompatibility } from "./layerCompatState.js";
 import { ContainerMessageType, } from "./messageTypes.js";
 import { DuplicateBatchDetector, ensureContentsDeserialized, OpCompressor, OpDecompressor, OpGroupingManager, OpSplitter, Outbox, RemoteMessageProcessor, serializeOpContents, } from "./opLifecycle/index.js";
 import { pkgVersion } from "./packageVersion.js";
 import { PendingStateManager, } from "./pendingStateManager.js";
-import { ScheduleManager } from "./scheduleManager.js";
-import { DocumentsSchemaController, OrderedClientCollection, OrderedClientElection, RetriableSummaryError, RunWhileConnectedCoordinator, Summarizer, SummarizerClientElection, SummaryCollection, SummaryManager, aliasBlobName, chunksBlobName, recentBatchInfoBlobName, createRootSummarizerNodeWithGC, electedSummarizerBlobName, extractSummaryMetadataMessage, idCompressorBlobName, metadataBlobName, rootHasIsolatedChannels, summarizerClientType, wrapSummaryInChannelsTree, } from "./summary/index.js";
+import { 
+// eslint-disable-next-line import/no-deprecated
+DocumentsSchemaController, OrderedClientCollection, OrderedClientElection, RetriableSummaryError, RunWhileConnectedCoordinator, 
+// eslint-disable-next-line import/no-deprecated
+Summarizer, SummarizerClientElection, SummaryCollection, SummaryManager, aliasBlobName, chunksBlobName, recentBatchInfoBlobName, createRootSummarizerNodeWithGC, electedSummarizerBlobName, extractSummaryMetadataMessage, idCompressorBlobName, metadataBlobName, rootHasIsolatedChannels, summarizerClientType, wrapSummaryInChannelsTree, } from "./summary/index.js";
 import { Throttler, formExponentialFn } from "./throttler.js";
 /**
  * Creates an error object to be thrown / passed to Container's close fn in case of an unknown message type.
@@ -50,6 +58,9 @@ function getUnknownMessageTypeError(unknownContainerRuntimeMessageType, codePath
         },
     });
 }
+export function isSummariesDisabled(config) {
+    return config.state === "disabled";
+}
 /**
  * @legacy
  * @alpha
@@ -65,13 +76,14 @@ export const DefaultSummaryConfiguration = {
     maxOpsSinceLastSummary: 7000,
     initialSummarizerDelayMs: 5 * 1000, // 5 secs.
     nonRuntimeOpWeight: 0.1,
-    runtimeOpWeight: 1.0,
+    runtimeOpWeight: 1,
     nonRuntimeHeuristicThreshold: 20,
 };
 /**
  * Error responses when requesting a deleted object will have this header set to true
  * @legacy
  * @alpha
+ * @deprecated This type will be moved to internal in 2.30. External usage is not necessary or supported.
  */
 export const DeletedResponseHeaderKey = "wasDeleted";
 /**
@@ -89,7 +101,9 @@ export const TombstoneResponseHeaderKey = "isTombstoned";
  * to this was experimental and is no longer supported.
  */
 export const InactiveResponseHeaderKey = "isInactive";
-/** Default values for Runtime Headers */
+/**
+ * Default values for Runtime Headers
+ */
 export const defaultRuntimeHeaderData = {
     wait: true,
     viaHandle: false,
@@ -109,7 +123,7 @@ export var CompressionAlgorithms;
  * @alpha
  */
 export const disabledCompressionConfig = {
-    minimumBatchSizeInBytes: Infinity,
+    minimumBatchSizeInBytes: Number.POSITIVE_INFINITY,
     compressionAlgorithm: CompressionAlgorithms.lz4,
 };
 const maxConsecutiveReconnectsKey = "Fluid.ContainerRuntime.MaxConsecutiveReconnects";
@@ -125,9 +139,13 @@ const defaultCompressionConfig = {
     compressionAlgorithm: CompressionAlgorithms.lz4,
 };
 const defaultChunkSizeInBytes = 204800;
-/** The default time to wait for pending ops to be processed during summarization */
+/**
+ * The default time to wait for pending ops to be processed during summarization
+ */
 export const defaultPendingOpsWaitTimeoutMs = 1000;
-/** The default time to delay a summarization retry attempt when there are pending ops */
+/**
+ * The default time to delay a summarization retry attempt when there are pending ops
+ */
 export const defaultPendingOpsRetryDelayMs = 1000;
 /**
  * Instead of refreshing from latest because we do not have 100% confidence in the state
@@ -153,12 +171,15 @@ export function getDeviceSpec() {
     try {
         if (typeof navigator === "object" && navigator !== null) {
             return {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
                 deviceMemory: navigator.deviceMemory,
                 hardwareConcurrency: navigator.hardwareConcurrency,
             };
         }
     }
-    catch { }
+    catch {
+        // Eat the error
+    }
     return {};
 }
 /**
@@ -199,18 +220,20 @@ async function createSummarizer(loader, url) {
     let fluidObject;
     // Older containers may not have the "getEntryPoint" API
     // ! This check will need to stay until LTS of loader moves past 2.0.0-internal.7.0.0
-    if (resolvedContainer.getEntryPoint !== undefined) {
-        fluidObject = await resolvedContainer.getEntryPoint();
-    }
-    else {
-        const response = await resolvedContainer.request({
+    if (resolvedContainer.getEntryPoint === undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any
+        const response = (await resolvedContainer.request({
             url: `/${summarizerRequestUrl}`,
-        });
+        }));
         if (response.status !== 200 || response.mimeType !== "fluid/object") {
             throw responseToException(response, request);
         }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         fluidObject = response.value;
     }
+    else {
+        fluidObject = await resolvedContainer.getEntryPoint();
+    }
     if (fluidObject?.ISummarizer === undefined) {
         throw new UsageError("Fluid object does not implement ISummarizer");
     }
@@ -222,7 +245,9 @@ async function createSummarizer(loader, url) {
  * This allows new runtime to make documents not openable for old runtimes, one explicit document schema control is enabled.
  * Please see addMetadataToSummary() as well
  */
-function lastMessageFromMetadata(metadata) {
+function lastMessageFromMetadata(
+// eslint-disable-next-line import/no-deprecated
+metadata) {
     return metadata?.documentSchema?.runtime?.explicitSchemaControl
         ? metadata?.lastMessage
         : metadata?.message;
@@ -239,6 +264,7 @@ export let getSingleUseLegacyLogCallback = (logger, type) => {
             details: { codePath, type },
         });
         // Now that we've logged, prevent future logging (globally).
+        // eslint-disable-next-line unicorn/consistent-function-scoping
         getSingleUseLegacyLogCallback = () => () => { };
     };
 };
@@ -252,15 +278,13 @@ export let getSingleUseLegacyLogCallback = (logger, type) => {
 export async function loadContainerRuntime(params) {
     return ContainerRuntime.loadRuntime(params);
 }
+const defaultMaxConsecutiveReconnects = 7;
+const defaultTelemetrySignalSampleCount = 100;
 /**
  * Represents the runtime of the container. Contains helper functions/state of the container.
  * It will define the store level mappings.
  *
- * @deprecated To be removed from the Legacy-Alpha API in version 2.20.0.
- * Use the loadContainerRuntime function and interfaces IContainerRuntime / IRuntime instead.
- *
- * @legacy
- * @alpha
+ * @internal
  */
 export class ContainerRuntime extends TypedEventEmitter {
     /**
@@ -295,7 +319,9 @@ export class ContainerRuntime extends TypedEventEmitter {
             },
         });
         const mc = loggerToMonitoringContext(logger);
-        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, compressionOptions = defaultCompressionConfig, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, enableRuntimeIdCompressor, chunkSizeInBytes = defaultChunkSizeInBytes, enableGroupedBatching = true, explicitSchemaControl = false, } = runtimeOptions;
+        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, compressionOptions = runtimeOptions.enableGroupedBatching === false
+            ? disabledCompressionConfig // Compression must be disabled if Grouping is disabled
+            : defaultCompressionConfig, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, enableRuntimeIdCompressor, chunkSizeInBytes = defaultChunkSizeInBytes, enableGroupedBatching = true, explicitSchemaControl = false, } = runtimeOptions;
         const registry = new FluidDataStoreRegistry(registryEntries);
         const tryFetchBlob = async (blobName) => {
             const blobId = context.baseSnapshot?.blobs[blobName];
@@ -309,7 +335,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         const [chunks, recentBatchInfo, metadata, electedSummarizerData, aliases, serializedIdCompressor,] = await Promise.all([
             tryFetchBlob(chunksBlobName),
             tryFetchBlob(recentBatchInfoBlobName),
+            // eslint-disable-next-line import/no-deprecated
             tryFetchBlob(metadataBlobName),
+            // eslint-disable-next-line import/no-deprecated
             tryFetchBlob(electedSummarizerBlobName),
             tryFetchBlob(aliasBlobName),
             tryFetchBlob(idCompressorBlobName),
@@ -323,6 +351,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         // When we load with pending state, we reuse an old snapshot so we don't expect these numbers to match
         if (!context.pendingLocalState && runtimeSequenceNumber !== undefined) {
             // Unless bypass is explicitly set, then take action when sequence numbers mismatch.
+            // eslint-disable-next-line unicorn/no-lonely-if -- Separate if statements make flow easier to parse
             if (loadSequenceNumberVerification !== "bypass" &&
                 runtimeSequenceNumber !== protocolSequenceNumber) {
                 // Message to OCEs:
@@ -345,15 +374,18 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         let desiredIdCompressorMode;
         switch (mc.config.getBoolean("Fluid.ContainerRuntime.IdCompressorEnabled")) {
-            case true:
+            case true: {
                 desiredIdCompressorMode = "on";
                 break;
-            case false:
+            }
+            case false: {
                 desiredIdCompressorMode = undefined;
                 break;
-            default:
+            }
+            default: {
                 desiredIdCompressorMode = enableRuntimeIdCompressor;
                 break;
+            }
         }
         // Enabling the IdCompressor is a one-way operation and we only want to
         // allow new containers to turn it on.
@@ -406,15 +438,16 @@ export class ContainerRuntime extends TypedEventEmitter {
             if (pendingLocalState?.pendingIdCompressorState !== undefined) {
                 return deserializeIdCompressor(pendingLocalState.pendingIdCompressorState, compressorLogger);
             }
-            else if (serializedIdCompressor !== undefined) {
-                return deserializeIdCompressor(serializedIdCompressor, createSessionId(), compressorLogger);
+            else if (serializedIdCompressor === undefined) {
+                return createIdCompressor(compressorLogger);
             }
             else {
-                return createIdCompressor(compressorLogger);
+                return deserializeIdCompressor(serializedIdCompressor, createSessionId(), compressorLogger);
             }
         };
-        const compressionLz4 = compressionOptions.minimumBatchSizeInBytes !== Infinity &&
+        const compressionLz4 = compressionOptions.minimumBatchSizeInBytes !== Number.POSITIVE_INFINITY &&
             compressionOptions.compressionAlgorithm === "lz4";
+        // eslint-disable-next-line import/no-deprecated
         const documentSchemaController = new DocumentsSchemaController(existing, protocolSequenceNumber, metadata?.documentSchema, {
             explicitSchemaControl,
             compressionLz4,
@@ -424,6 +457,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         }, (schema) => {
             runtime.onSchemaChange(schema);
         });
+        if (compressionLz4 && !enableGroupedBatching) {
+            throw new UsageError("If compression is enabled, op grouping must be enabled too");
+        }
         const featureGatesForTelemetry = {};
         // Make sure we've got all the options including internal ones
         const internalRuntimeOptions = {
@@ -484,29 +520,26 @@ export class ContainerRuntime extends TypedEventEmitter {
      * has to deal with compressed ops as other clients might send them.
      * And in reverse, session schema can have compression Off, but feature gates / runtime options want it On.
      * In such case it will be off in session schema, however this client will propose change to schema, and once / if
-     * this op rountrips, compression will be On. Client can't send compressed ops until it's change in schema.
+     * this op roundtrips, compression will be On. Client can't send compressed ops until it's change in schema.
      */
     get sessionSchema() {
         return this.documentsSchemaController.sessionSchema.runtime;
     }
-    get idCompressorMode() {
-        return this.sessionSchema.idCompressorMode;
-    }
     /**
-     * See IContainerRuntimeBase.idCompressor() for details.
+     * {@inheritDoc @fluidframework/runtime-definitions#IContainerRuntimeBase.idCompressor}
      */
     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") {
+        if (this.sessionSchema.idCompressorMode === "on") {
             assert(this._idCompressor !== undefined, 0x8ea /* compressor should have been loaded */);
             return this._idCompressor;
         }
     }
     /**
-     * See IContainerRuntimeBase.generateDocumentUniqueId() for details.
+     * {@inheritDoc @fluidframework/runtime-definitions#IContainerRuntimeBase.generateDocumentUniqueId}
      */
     generateDocumentUniqueId() {
         return this._idCompressor?.generateDocumentUniqueId() ?? uuid();
@@ -542,35 +575,15 @@ export class ContainerRuntime extends TypedEventEmitter {
     get connected() {
         return this._connected;
     }
-    /** clientId of parent (non-summarizing) container that owns summarizer container */
+    /**
+     * clientId of parent (non-summarizing) container that owns summarizer container
+     */
     get summarizerClientId() {
         return this.summarizerClientElection?.electedClientId;
     }
     get disposed() {
         return this._disposed;
     }
-    get summarizer() {
-        assert(this._summarizer !== undefined, 0x257 /* "This is not summarizing container" */);
-        return this._summarizer;
-    }
-    isSummariesDisabled() {
-        return this.summaryConfiguration.state === "disabled";
-    }
-    getMaxOpsSinceLastSummary() {
-        return this.summaryConfiguration.state !== "disabled"
-            ? this.summaryConfiguration.maxOpsSinceLastSummary
-            : 0;
-    }
-    getInitialSummarizerDelayMs() {
-        // back-compat: initialSummarizerDelayMs was moved from ISummaryRuntimeOptions
-        //   to ISummaryConfiguration in 0.60.
-        if (this.runtimeOptions.summaryOptions.initialSummarizerDelayMs !== undefined) {
-            return this.runtimeOptions.summaryOptions.initialSummarizerDelayMs;
-        }
-        return this.summaryConfiguration.state !== "disabled"
-            ? this.summaryConfiguration.initialSummarizerDelayMs
-            : 0;
-    }
     /**
      * If false, loading or using a Tombstoned object should merely log, not fail.
      * @deprecated NOT SUPPORTED - hardcoded to return false since it's deprecated.
@@ -587,14 +600,27 @@ export class ContainerRuntime extends TypedEventEmitter {
     get gcThrowOnTombstoneUsage() {
         return false;
     }
+    get ILayerCompatDetails() {
+        return RuntimeCompatDetails;
+    }
     /***/
-    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, 
+    constructor(context, registry, 
+    // eslint-disable-next-line import/no-deprecated
+    metadata, 
+    // eslint-disable-next-line import/no-deprecated
+    electedSummarizerData, chunks, dataStoreAliasMap, baseRuntimeOptions, containerScope, 
     // Create a custom ITelemetryBaseLogger to output telemetry events.
-    baseLogger, existing, blobManagerSnapshot, _storage, createIdCompressor, documentsSchemaController, featureGatesForTelemetry, provideEntryPoint, requestHandler, summaryConfiguration = {
+    baseLogger, existing, 
+    // eslint-disable-next-line import/no-deprecated
+    blobManagerSnapshot, _storage, createIdCompressor, 
+    // eslint-disable-next-line import/no-deprecated
+    documentsSchemaController, featureGatesForTelemetry, provideEntryPoint, requestHandler, 
+    // eslint-disable-next-line unicorn/no-object-as-default-parameter
+    summaryConfiguration = {
         // the defaults
         ...DefaultSummaryConfiguration,
         // the runtime configuration overrides
-        ...runtimeOptions.summaryOptions?.summaryConfigOverrides,
+        ...baseRuntimeOptions.summaryOptions?.summaryConfigOverrides,
     }, recentBatchInfo) {
         super();
         this.registry = registry;
@@ -605,19 +631,16 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.createIdCompressor = createIdCompressor;
         this.documentsSchemaController = documentsSchemaController;
         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 = [];
-        this.defaultMaxConsecutiveReconnects = 7;
         this._orderSequentiallyCalls = 0;
         this.flushTaskExists = false;
         this.consecutiveReconnects = 0;
         this.ensureNoDataModelChangesCalls = 0;
         this._disposed = false;
         this.emitDirtyDocumentEvent = true;
-        this.defaultTelemetrySignalSampleCount = 100;
         this._signalTracking = {
             totalSignalsSentInLatencyWindow: 0,
             signalsLost: 0,
@@ -636,16 +659,19 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.snapshotCacheForLoadingGroupIds = new PromiseCache({
             expiry: { policy: "absolute", durationMs: 60000 },
         });
+        this.readAndParseBlob = async (id) => readAndParse(this.storage, id);
         const { options, clientDetails, connected, baseSnapshot, submitFn, submitBatchFn, submitSummaryFn, submitSignalFn, disposeFn, closeFn, deltaManager, quorum, audience, loader, pendingLocalState, supportedFeatures, snapshotWithContents, } = context;
+        // In old loaders without dispose functionality, closeFn is equivalent but will also switch container to readonly mode
+        this.disposeFn = disposeFn ?? closeFn;
+        const maybeLoaderCompatDetails = context;
+        validateLoaderCompatibility(maybeLoaderCompatDetails.ILayerCompatDetails, this.disposeFn);
         // Backfill in defaults for the internal runtimeOptions, since they may not be present on the provided runtimeOptions object
-        this.runtimeOptions = {
+        const runtimeOptions = {
             flushMode: defaultFlushMode,
-            enableGroupedBatching: true,
-            ...runtimeOptions,
+            ...baseRuntimeOptions,
         };
-        this.logger = createChildLogger({ logger: this.baseLogger });
         this.mc = createChildMonitoringContext({
-            logger: this.logger,
+            logger: this.baseLogger,
             namespace: "ContainerRuntime",
         });
         // If we support multiple algorithms in the future, then we would need to manage it here carefully.
@@ -662,19 +688,23 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.innerDeltaManager = deltaManager;
         // 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;
+        // back-compat: ADO #1385: Make this call unconditional in the future
+        this.submitSummaryFn =
+            submitSummaryFn ??
+                ((summaryOp, refseq) => submitFn(MessageType.Summarize, summaryOp, false));
         this.submitSignalFn = submitSignalFn;
         // TODO: After IContainerContext.options is removed, we'll just create a new blank object {} here.
         // Values are generally expected to be set from the runtime side.
         this.options = options ?? {};
         this.clientDetails = clientDetails;
-        this.isSummarizerClient = this.clientDetails.type === summarizerClientType;
+        const isSummarizerClient = this.clientDetails.type === summarizerClientType;
         this.loadedFromVersionId = context.getLoadedFromVersion()?.id;
+        // eslint-disable-next-line unicorn/consistent-destructuring
         this._getClientId = () => context.clientId;
+        // eslint-disable-next-line unicorn/consistent-destructuring
         this._getAttachState = () => context.attachState;
         this.getAbsoluteUrl = async (relativeUrl) => {
+            // eslint-disable-next-line unicorn/consistent-destructuring
             if (context.getAbsoluteUrl === undefined) {
                 throw new Error("Driver does not implement getAbsoluteUrl");
             }
@@ -687,10 +717,8 @@ export class ContainerRuntime extends TypedEventEmitter {
         // customer should observe dirty state on the runtime (the owner of dirty state) directly, rather than on the IContainer.
         this.on("dirty", () => context.updateDirtyContainerState(true));
         this.on("saved", () => context.updateDirtyContainerState(false));
-        // In old loaders without dispose functionality, closeFn is equivalent but will also switch container to readonly mode
-        this.disposeFn = disposeFn ?? closeFn;
         // In cases of summarizer, we want to dispose instead since consumer doesn't interact with this container
-        this.closeFn = this.isSummarizerClient ? this.disposeFn : closeFn;
+        this.closeFn = isSummarizerClient ? this.disposeFn : closeFn;
         let loadSummaryNumber;
         // Get the container creation metadata. For new container, we initialize these. For existing containers,
         // get the values from the metadata blob.
@@ -719,18 +747,15 @@ export class ContainerRuntime extends TypedEventEmitter {
             eventName: "GCFeatureMatrix",
             metadataValue: JSON.stringify(metadata?.gcFeatureMatrix),
             inputs: JSON.stringify({
-                gcOptions_gcGeneration: this.runtimeOptions.gcOptions[gcGenerationOptionName],
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                gcOptions_gcGeneration: runtimeOptions.gcOptions[gcGenerationOptionName],
             }),
         });
         this.telemetryDocumentId = metadata?.telemetryDocumentId ?? uuid();
-        this.disableAttachReorder = this.mc.config.getBoolean("Fluid.ContainerRuntime.disableAttachOpReorder");
         const opGroupingManager = new 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 OpSplitter(chunks, this.submitBatchFn, runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger);
+        const opSplitter = new OpSplitter(chunks, submitBatchFn, runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger);
         this.remoteMessageProcessor = new RemoteMessageProcessor(opSplitter, new OpDecompressor(this.mc.logger), opGroupingManager);
         const pendingRuntimeState = pendingLocalState;
         this.pendingStateManager = new PendingStateManager({
@@ -740,7 +765,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             reSubmitBatch: this.reSubmitBatch.bind(this),
             isActiveConnection: () => this.innerDeltaManager.active,
             isAttached: () => this.attachState !== AttachState.Detached,
-        }, pendingRuntimeState?.pending, this.logger);
+        }, pendingRuntimeState?.pending, this.baseLogger);
         let outerDeltaManager;
         this.useDeltaManagerOpsProxy =
             this.mc.config.getBoolean("Fluid.ContainerRuntime.DeltaManagerOpsProxy") === true;
@@ -755,24 +780,35 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         this._deltaManager = outerDeltaManager;
         this.handleContext = new ContainerFluidHandleContext("", this);
-        if (this.summaryConfiguration.state === "enabled") {
-            this.validateSummaryHeuristicConfiguration(this.summaryConfiguration);
-        }
-        this.summariesDisabled = this.isSummariesDisabled();
-        this.maxOpsSinceLastSummary = this.getMaxOpsSinceLastSummary();
-        this.initialSummarizerDelayMs = this.getInitialSummarizerDelayMs();
+        if (summaryConfiguration.state === "enabled") {
+            this.validateSummaryHeuristicConfiguration(summaryConfiguration);
+        }
+        this.summariesDisabled = isSummariesDisabled(summaryConfiguration);
+        const { maxOpsSinceLastSummary = 0, initialSummarizerDelayMs = 0 } = isSummariesDisabled(summaryConfiguration)
+            ? {}
+            : {
+                ...summaryConfiguration,
+                initialSummarizerDelayMs: 
+                // back-compat: initialSummarizerDelayMs was moved from ISummaryRuntimeOptions
+                //   to ISummaryConfiguration in 0.60.
+                runtimeOptions.summaryOptions.initialSummarizerDelayMs ??
+                    summaryConfiguration.initialSummarizerDelayMs,
+            };
         this.maxConsecutiveReconnects =
-            this.mc.config.getNumber(maxConsecutiveReconnectsKey) ??
-                this.defaultMaxConsecutiveReconnects;
-        if (this.runtimeOptions.flushMode ===
-            FlushModeExperimental.Async &&
-            supportedFeatures?.get("referenceSequenceNumbers") !== true) {
+            this.mc.config.getNumber(maxConsecutiveReconnectsKey) ?? defaultMaxConsecutiveReconnects;
+        // If the context has ILayerCompatDetails, it supports referenceSequenceNumbers since that features
+        // predates ILayerCompatDetails.
+        const referenceSequenceNumbersSupported = maybeLoaderCompatDetails.ILayerCompatDetails === undefined
+            ? supportedFeatures?.get("referenceSequenceNumbers") === true
+            : true;
+        if (runtimeOptions.flushMode === FlushModeExperimental.Async &&
+            !referenceSequenceNumbersSupported) {
             // The loader does not support reference sequence numbers, falling back on FlushMode.TurnBased
             this.mc.logger.sendErrorEvent({ eventName: "FlushModeFallback" });
             this._flushMode = FlushMode.TurnBased;
         }
         else {
-            this._flushMode = this.runtimeOptions.flushMode;
+            this._flushMode = runtimeOptions.flushMode;
         }
         this.offlineEnabled =
             this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad") ?? false;
@@ -787,6 +823,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (this.offlineEnabled) {
             this.duplicateBatchDetector = new DuplicateBatchDetector(recentBatchInfo);
         }
+        // eslint-disable-next-line unicorn/consistent-destructuring
         if (context.attachState === AttachState.Attached) {
             const maxSnapshotCacheDurationMs = this._storage?.policies?.maximumCacheDurationMs;
             if (maxSnapshotCacheDurationMs !== undefined &&
@@ -799,13 +836,13 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         this.garbageCollector = GarbageCollector.create({
             runtime: this,
-            gcOptions: this.runtimeOptions.gcOptions,
+            gcOptions: runtimeOptions.gcOptions,
             baseSnapshot,
             baseLogger: this.mc.logger,
             existing,
             metadata,
             createContainerMetadata: this.createContainerMetadata,
-            isSummarizerClient: this.isSummarizerClient,
+            isSummarizerClient,
             getNodePackagePath: async (nodePath) => this.getGCNodePackagePath(nodePath),
             getLastSummaryTimestampMs: () => this.messageAtLastSummary?.timestamp,
             readAndParseBlob: async (id) => readAndParse(this.storage, id),
@@ -819,7 +856,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         const summaryReferenceSequenceNumber = baseSnapshot === undefined || metadata?.disableIsolatedChannels === true
             ? undefined
             : loadedFromSequenceNumber;
-        this.summarizerNode = createRootSummarizerNodeWithGC(createChildLogger({ logger: this.logger, namespace: "SummarizerNode" }), 
+        this.summarizerNode = createRootSummarizerNodeWithGC(createChildLogger({ logger: this.baseLogger, 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
@@ -879,13 +916,14 @@ export class ContainerRuntime extends TypedEventEmitter {
             stashedBlobs: pendingRuntimeState?.pendingAttachmentBlobs,
             closeContainer: (error) => this.closeFn(error),
         });
-        this.scheduleManager = new ScheduleManager(this.innerDeltaManager, this, () => this.clientId, createChildLogger({ logger: this.logger, namespace: "ScheduleManager" }));
+        this.deltaScheduler = new DeltaScheduler(this.innerDeltaManager, this, createChildLogger({ logger: this.baseLogger, namespace: "DeltaScheduler" }));
+        this.inboundBatchAggregator = new InboundBatchAggregator(this.innerDeltaManager, () => this.clientId, createChildLogger({ logger: this.baseLogger, namespace: "InboundBatchAggregator" }));
         const disablePartialFlush = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisablePartialFlush");
-        const legacySendBatchFn = makeLegacySendBatchFn(this.submitFn, this.innerDeltaManager);
+        const legacySendBatchFn = makeLegacySendBatchFn(submitFn, this.innerDeltaManager);
         this.outbox = new Outbox({
             shouldSend: () => this.canSendOps(),
             pendingStateManager: this.pendingStateManager,
-            submitBatchFn: this.submitBatchFn,
+            submitBatchFn,
             legacySendBatchFn,
             compressor: new OpCompressor(this.mc.logger),
             splitter: opSplitter,
@@ -932,7 +970,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         const closeSummarizerDelayOverride = this.mc.config.getNumber("Fluid.ContainerRuntime.Test.CloseSummarizerDelayOverrideMs");
         this.closeSummarizerDelayMs =
             closeSummarizerDelayOverride ?? defaultCloseSummarizerDelayMs;
-        this.summaryCollection = new SummaryCollection(this.deltaManager, this.logger);
+        const summaryCollection = new SummaryCollection(this.deltaManager, this.baseLogger);
         this.dirtyContainer =
             this.attachState !== AttachState.Attached || this.hasPendingMessages();
         context.updateDirtyContainerState(this.dirtyContainer);
@@ -941,14 +979,17 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         else {
             const orderedClientLogger = createChildLogger({
-                logger: this.logger,
+                logger: this.baseLogger,
                 namespace: "OrderedClientElection",
             });
             const orderedClientCollection = new OrderedClientCollection(orderedClientLogger, this.innerDeltaManager, this._quorum);
             const orderedClientElectionForSummarizer = new OrderedClientElection(orderedClientLogger, orderedClientCollection, electedSummarizerData ?? this.innerDeltaManager.lastSequenceNumber, SummarizerClientElection.isClientEligible, this.mc.config.getBoolean("Fluid.ContainerRuntime.OrderedClientElection.EnablePerformanceEvents"));
-            this.summarizerClientElection = new SummarizerClientElection(orderedClientLogger, this.summaryCollection, orderedClientElectionForSummarizer, this.maxOpsSinceLastSummary);
-            if (this.isSummarizerClient) {
-                this._summarizer = new Summarizer(this /* ISummarizerRuntime */, () => this.summaryConfiguration, this /* ISummarizerInternalsProvider */, this.handleContext, this.summaryCollection, async (runtime) => RunWhileConnectedCoordinator.create(runtime, 
+            this.summarizerClientElection = new SummarizerClientElection(orderedClientLogger, summaryCollection, orderedClientElectionForSummarizer, maxOpsSinceLastSummary);
+            if (isSummarizerClient) {
+                // eslint-disable-next-line import/no-deprecated
+                this._summarizer = new Summarizer(this /* ISummarizerRuntime */, () => summaryConfiguration, this /* ISummarizerInternalsProvider */, this.handleContext, summaryCollection, 
+                // eslint-disable-next-line import/no-deprecated
+                async (runtime) => 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));
@@ -957,48 +998,49 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // Only create a SummaryManager and SummarizerClientElection
                 // if summaries are enabled and we are not the summarizer client.
                 const defaultAction = () => {
-                    if (this.summaryCollection.opsSinceLastAck > this.maxOpsSinceLastSummary) {
+                    if (summaryCollection.opsSinceLastAck > maxOpsSinceLastSummary) {
                         this.mc.logger.sendTelemetryEvent({ eventName: "SummaryStatus:Behind" });
                         // unregister default to no log on every op after falling behind
                         // and register summary ack handler to re-register this handler
                         // after successful summary
-                        this.summaryCollection.once(MessageType.SummaryAck, () => {
+                        summaryCollection.once(MessageType.SummaryAck, () => {
                             this.mc.logger.sendTelemetryEvent({
                                 eventName: "SummaryStatus:CaughtUp",
                             });
                             // we've caught up, so re-register the default action to monitor for
                             // falling behind, and unregister ourself
-                            this.summaryCollection.on("default", defaultAction);
+                            summaryCollection.on("default", defaultAction);
                         });
-                        this.summaryCollection.off("default", defaultAction);
+                        summaryCollection.off("default", defaultAction);
                     }
                 };
-                this.summaryCollection.on("default", defaultAction);
+                summaryCollection.on("default", defaultAction);
                 // Create the SummaryManager and mark the initial state
                 this.summaryManager = new SummaryManager(this.summarizerClientElection, this, // IConnectedState
-                this.summaryCollection, this.logger, this.formCreateSummarizerFn(loader), new Throttler(60 * 1000, // 60 sec delay window
+                summaryCollection, this.baseLogger, this.formCreateSummarizerFn(loader), new Throttler(60 * 1000, // 60 sec delay window
                 30 * 1000, // 30 sec max delay
                 // throttling function increases exponentially (0ms, 40ms, 80ms, 160ms, etc)
                 formExponentialFn({ coefficient: 20, initialDelay: 0 })), {
-                    initialDelayMs: this.initialSummarizerDelayMs,
+                    initialDelayMs: initialSummarizerDelayMs,
                 });
                 // Forward events from SummaryManager
-                [
+                for (const eventName of [
                     "summarize",
                     "summarizeAllAttemptsFailed",
                     "summarizerStop",
                     "summarizerStart",
                     "summarizerStartupFailed",
-                ].forEach((eventName) => {
+                ]) {
                     this.summaryManager?.on(eventName, (...args) => {
                         this.emit(eventName, ...args);
                     });
-                });
+                }
                 this.summaryManager.start();
             }
         }
         // logging hardware telemetry
-        this.logger.sendTelemetryEvent({
+        this.baseLogger.send({
+            category: "generic",
             eventName: "DeviceSpec",
             ...getDeviceSpec(),
         });
@@ -1010,13 +1052,12 @@ export class ContainerRuntime extends TypedEventEmitter {
             summaryFormatVersion: metadata?.summaryFormatVersion,
             disableIsolatedChannels: metadata?.disableIsolatedChannels,
             gcVersion: metadata?.gcFeature,
-            options: JSON.stringify(runtimeOptions),
+            options: JSON.stringify(baseRuntimeOptions),
             idCompressorModeMetadata: metadata?.documentSchema?.runtime?.idCompressorMode,
-            idCompressorMode: this.idCompressorMode,
+            idCompressorMode: this.sessionSchema.idCompressorMode,
             sessionRuntimeSchema: JSON.stringify(this.sessionSchema),
             featureGates: JSON.stringify({
                 ...featureGatesForTelemetry,
-                disableAttachReorder: this.disableAttachReorder,
                 disablePartialFlush,
                 closeSummarizerDelayOverride,
             }),
@@ -1024,11 +1065,10 @@ export class ContainerRuntime extends TypedEventEmitter {
             groupedBatchingEnabled: this.groupedBatchingEnabled,
             initialSequenceNumber: this.deltaManager.initialSequenceNumber,
         });
-        ReportOpPerfTelemetry(this.clientId, this._deltaManager, this, this.logger);
-        BindBatchTracker(this, this.logger);
+        ReportOpPerfTelemetry(this.clientId, this._deltaManager, this, this.baseLogger);
+        BindBatchTracker(this, this.baseLogger);
         this.entryPoint = new LazyPromise(async () => {
-            if (this.isSummarizerClient) {
-                assert(this._summarizer !== undefined, 0x5bf /* Summarizer object is undefined in a summarizer client */);
+            if (this._summarizer !== undefined) {
                 return this._summarizer;
             }
             return provideEntryPoint(this);
@@ -1037,8 +1077,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         // saved state, i.e. all the ops marked by Loader layer sa savedOp === true.
         this.skipSavedCompressorOps = pendingRuntimeState?.pendingIdCompressorState !== undefined;
     }
+    // eslint-disable-next-line import/no-deprecated
     onSchemaChange(schema) {
-        this.logger.sendTelemetryEvent({
+        this.mc.logger.sendTelemetryEvent({
             eventName: "SchemaChangeAccept",
             sessionRuntimeSchema: JSON.stringify(schema),
         });
@@ -1061,19 +1102,20 @@ export class ContainerRuntime extends TypedEventEmitter {
     deleteChildSummarizerNode(id) {
         return this.summarizerNode.deleteChild(id);
     }
-    /* IFluidParentContext APIs that should not be called on Root */
+    // #region `IFluidParentContext` APIs that should not be called on Root
     makeLocallyVisible() {
         assert(false, 0x8eb /* should not be called */);
     }
     setChannelDirty(address) {
         assert(false, 0x909 /* should not be called */);
     }
+    // #endregion
     /**
      * Initializes the state from the base snapshot this container runtime loaded from.
      */
     async initializeBaseState() {
-        if (this.idCompressorMode === "on" ||
-            (this.idCompressorMode === "delayed" && this.connected)) {
+        if (this.sessionSchema.idCompressorMode === "on" ||
+            (this.sessionSchema.idCompressorMode === "delayed" && this.connected)) {
             this._idCompressor = await this.createIdCompressor();
             // This is called from loadRuntime(), long before we process any ops, so there should be no ops accumulated yet.
             assert(this.pendingIdCompressorOps.length === 0, 0x8ec /* no pending ops */);
@@ -1098,6 +1140,8 @@ export class ContainerRuntime extends TypedEventEmitter {
         this._summarizer?.dispose();
         this.channelCollection.dispose();
         this.pendingStateManager.dispose();
+        this.inboundBatchAggregator.dispose();
+        this.deltaScheduler.dispose();
         this.emit("dispose");
         this.removeAllListeners();
     }
@@ -1114,7 +1158,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         // 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 () => {
+        const snapshot = await this.snapshotCacheForLoadingGroupIds.addOrGet(sortedLoadingGroupIds.join(","), async () => {
             assert(this.storage.getSnapshot !== undefined, 0x8ee /* getSnapshot api should be defined if used */);
             loadedFromCache = false;
             return this.storage.getSnapshot({
@@ -1123,7 +1167,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 loadingGroupIds: sortedLoadingGroupIds,
             });
         });
-        this.logger.sendTelemetryEvent({
+        this.mc.logger.sendTelemetryEvent({
             eventName: "GroupIdSnapshotFetched",
             details: JSON.stringify({
                 fromCache: loadedFromCache,
@@ -1153,7 +1197,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             // 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) {
+            if (this._summarizer !== undefined) {
                 throw new Error("Summarizer client behind, loaded newer snapshot with loadingGroupId");
             }
             // We want to catchup from sequenceNumber to targetSequenceNumber
@@ -1215,7 +1259,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                     return {
                         status: 200,
                         mimeType: "fluid/object",
-                        value: this.summarizer,
+                        value: this._summarizer,
                     };
                 }
                 return create404Response(request);
@@ -1270,7 +1314,9 @@ export class ContainerRuntime extends TypedEventEmitter {
     internalId(maybeAlias) {
         return this.channelCollection.internalId(maybeAlias);
     }
-    /** Adds the container's metadata to the given summary tree. */
+    /**
+     * Adds the container's metadata to the given summary tree.
+     */
     addMetadataToSummary(summaryTree) {
         // The last message processed at the time of summary. If there are no new messages, use the message from the
         // last summary.
@@ -1279,6 +1325,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         const documentSchema = this.documentsSchemaController.summarizeDocumentSchema(this.deltaManager.lastSequenceNumber);
         // Is document schema explicit control on?
         const explicitSchemaControl = documentSchema?.runtime.explicitSchemaControl;
+        // eslint-disable-next-line import/no-deprecated
         const metadata = {
             ...this.createContainerMetadata,
             // Increment the summary number for the next summary that will be generated.
@@ -1292,7 +1339,8 @@ export class ContainerRuntime extends TypedEventEmitter {
             // last message's sequence number.
             // See also lastMessageFromMetadata()
             message: explicitSchemaControl
-                ? { sequenceNumber: -1 }
+                ? // eslint-disable-next-line import/no-deprecated
+                    { sequenceNumber: -1 }
                 : message,
             lastMessage: explicitSchemaControl ? message : undefined,
             documentSchema,
@@ -1408,9 +1456,10 @@ export class ContainerRuntime extends TypedEventEmitter {
         switch (opContents.type) {
             case ContainerMessageType.FluidDataStoreOp:
             case ContainerMessageType.Attach:
-            case ContainerMessageType.Alias:
+            case ContainerMessageType.Alias: {
                 return this.channelCollection.applyStashedOp(opContents);
-            case ContainerMessageType.IdAllocation:
+            }
+            case ContainerMessageType.IdAllocation: {
                 // IDs allocation ops in stashed state are ignored because the tip state of the compressor
                 // is serialized into the pending state. This is done because generation of new IDs during
                 // stashed op application (or, later, resubmit) must generate new IDs and if the compressor
@@ -1420,17 +1469,22 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // and the runtime could filter out all ID allocation ops from the stashed state and apply them
                 // before applying the rest of the stashed ops. This would accomplish the same thing but with
                 // better performance in future incremental stashed state creation.
-                assert(this.idCompressorMode !== undefined, 0x8f1 /* ID compressor should be in use */);
+                assert(this.sessionSchema.idCompressorMode !== undefined, 0x8f1 /* ID compressor should be in use */);
                 return;
-            case ContainerMessageType.DocumentSchemaChange:
+            }
+            case ContainerMessageType.DocumentSchemaChange: {
                 return;
-            case ContainerMessageType.BlobAttach:
+            }
+            case ContainerMessageType.BlobAttach: {
                 return;
-            case ContainerMessageType.Rejoin:
+            }
+            case ContainerMessageType.Rejoin: {
                 throw new Error("rejoin not expected here");
-            case ContainerMessageType.GC:
+            }
+            case ContainerMessageType.GC: {
                 // GC op is only sent in summarizer which should never have stashed ops.
                 throw new LoggingError("GC op not expected to be stashed in summarizer");
+            }
             default: {
                 const error = getUnknownMessageTypeError(opContents.type, "applyStashedOp" /* codePath */);
                 this.closeFn(error);
@@ -1440,7 +1494,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     async loadIdCompressor() {
         if (this._idCompressor === undefined &&
-            this.idCompressorMode !== undefined &&
+            this.sessionSchema.idCompressorMode !== undefined &&
             this._loadIdCompressor === undefined) {
             this._loadIdCompressor = this.createIdCompressor()
                 .then((compressor) => {
@@ -1454,7 +1508,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this._idCompressor = compressor;
             })
                 .catch((error) => {
-                this.logger.sendErrorEvent({ eventName: "IdCompressorDelayedLoad" }, error);
+                this.mc.logger.sendErrorEvent({ eventName: "IdCompressorDelayedLoad" }, error);
                 throw error;
             });
         }
@@ -1465,7 +1519,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         const currentClientId = this._audience.getSelf()?.clientId;
         assert(clientId === currentClientId, 0x977 /* input clientId does not match Audience */);
         assert(this.clientId === currentClientId, 0x978 /* this.clientId does not match Audience */);
-        if (connected && this.idCompressorMode === "delayed") {
+        if (connected && this.sessionSchema.idCompressorMode === "delayed") {
             // eslint-disable-next-line @typescript-eslint/no-floating-promises
             this.loadIdCompressor();
         }
@@ -1554,7 +1608,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         // or something different, like a system message.
         const hasModernRuntimeMessageEnvelope = messageCopy.type === MessageType.Operation;
         const savedOp = messageCopy.metadata?.savedOp;
-        const logLegacyCase = getSingleUseLegacyLogCallback(this.logger, messageCopy.type);
+        const logLegacyCase = getSingleUseLegacyLogCallback(this.mc.logger, messageCopy.type);
         let runtimeBatch = hasModernRuntimeMessageEnvelope || isUnpackedRuntimeMessage(messageCopy);
         if (runtimeBatch) {
             // We expect runtime messages to have JSON contents - deserialize it in place.
@@ -1639,7 +1693,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
     }
     /**
-     * Processes inbound message(s). It calls schedule manager according to the messages' location in the batch.
+     * Processes inbound message(s). It calls delta scheduler according to the messages' location in the batch.
      * @param messagesWithMetadata - messages to process along with their metadata.
      * @param locationInBatch - Are we processing the start and/or end of a batch?
      * @param local - true if the messages were originally generated by the client receiving it.
@@ -1651,19 +1705,19 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (locationInBatch.batchStart) {
             const firstMessage = messagesWithMetadata[0]?.message;
             assert(firstMessage !== undefined, 0xa31 /* Batch must have at least one message */);
-            this.scheduleManager.batchBegin(firstMessage);
+            this.emit("batchBegin", firstMessage);
         }
         let error;
         try {
             if (!runtimeBatch) {
-                messagesWithMetadata.forEach(({ message }) => {
+                for (const { message } of messagesWithMetadata) {
                     this.ensureNoDataModelChanges(() => {
                         this.observeNonRuntimeMessage(message);
                     });
-                });
+                }
                 return;
             }
-            // Helper that updates a message's minimum sequence number to the minimum sequence number that container
+            // Updates a message's minimum sequence number to the minimum sequence number that container
             // runtime is tracking and sets _processedClientSequenceNumber. It returns the updated message.
             const updateSequenceNumbers = (message) => {
                 // Set the minimum sequence number to the containerRuntime's understanding of minimum sequence number.
@@ -1694,7 +1748,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
             let bunchedMessagesContent = [];
             let previousMessage;
-            // Helper that processes the previous bunch of messages.
+            // Process the previous bunch of messages.
             const sendBunchedMessages = () => {
                 assert(previousMessage !== undefined, 0xa67 /* previous message must exist */);
                 this.ensureNoDataModelChanges(() => {
@@ -1728,15 +1782,15 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.emit("op", message, true /* runtimeMessage */);
             }
         }
-        catch (e) {
-            error = e;
+        catch (error_) {
+            error = error_;
             throw error;
         }
         finally {
             if (locationInBatch.batchEnd) {
                 const lastMessage = messagesWithMetadata[messagesWithMetadata.length - 1]?.message;
                 assert(lastMessage !== undefined, 0xa32 /* Batch must have at least one message */);
-                this.scheduleManager.batchEnd(error, lastMessage);
+                this.emit("batchEnd", error, lastMessage);
             }
         }
     }
@@ -1786,30 +1840,39 @@ export class ContainerRuntime extends TypedEventEmitter {
         switch (message.type) {
             case ContainerMessageType.FluidDataStoreOp:
             case ContainerMessageType.Attach:
-            case ContainerMessageType.Alias:
+            case ContainerMessageType.Alias: {
                 // Remove the metadata from the message before sending it to the channel collection. The metadata
                 // is added by the container runtime and is not part of the message that the channel collection and
                 // layers below it expect.
                 this.channelCollection.processMessages({ envelope: message, messagesContent, local });
                 break;
-            case ContainerMessageType.BlobAttach:
+            }
+            case ContainerMessageType.BlobAttach: {
                 this.blobManager.processBlobAttachMessage(message, local);
                 break;
-            case ContainerMessageType.IdAllocation:
+            }
+            case ContainerMessageType.IdAllocation: {
                 this.processIdCompressorMessages(contents, savedOp);
                 break;
-            case ContainerMessageType.GC:
+            }
+            case ContainerMessageType.GC: {
                 this.garbageCollector.processMessages(contents, message.timestamp, local);
                 break;
-            case ContainerMessageType.ChunkedOp:
+            }
+            case ContainerMessageType.ChunkedOp: {
                 // From observability POV, we should not expose the rest of the system (including "op" events on object) to these messages.
                 // Also resetReconnectCount() would be wrong - see comment that was there before this change was made.
                 assert(false, 0x93d /* should not even get here */);
-            case ContainerMessageType.Rejoin:
+            }
+            case ContainerMessageType.Rejoin: {
                 break;
-            case ContainerMessageType.DocumentSchemaChange:
-                this.documentsSchemaController.processDocumentSchemaMessages(contents, local, message.sequenceNumber);
+            }
+            case ContainerMessageType.DocumentSchemaChange: {
+                this.documentsSchemaController.processDocumentSchemaMessages(
+                // eslint-disable-next-line import/no-deprecated
+                contents, local, message.sequenceNumber);
                 break;
+            }
             default: {
                 const error = getUnknownMessageTypeError(message.type, "validateAndProcessRuntimeMessage" /* codePath */, message);
                 this.closeFn(error);
@@ -1827,7 +1890,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // Some other client turned on the id compressor. If we have not turned it on,
                 // put it in a pending queue and delay finalization.
                 if (this._idCompressor === undefined) {
-                    assert(this.idCompressorMode !== undefined, 0x93c /* id compressor should be enabled */);
+                    assert(this.sessionSchema.idCompressorMode !== undefined, 0x93c /* id compressor should be enabled */);
                     this.pendingIdCompressorOps.push(range);
                 }
                 else {
@@ -1861,7 +1924,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      * Updates signal telemetry including emitting telemetry events.
      */
     processSignalForTelemetry(envelope) {
-        const { clientBroadcastSignalSequenceNumber } = envelope;
+        const { clientBroadcastSignalSequenceNumber, contents: envelopeContents, address: envelopeAddress, } = envelope;
         if (clientBroadcastSignalSequenceNumber === undefined) {
             return;
         }
@@ -1899,8 +1962,8 @@ export class ContainerRuntime extends TypedEventEmitter {
             };
             // Only log `contents.type` when address is for container to avoid
             // chance that contents type is customer data.
-            if (envelope.address === undefined) {
-                details.contentsType = envelope.contents.type; // Type of signal that was received out of order.
+            if (envelopeAddress === undefined) {
+                details.contentsType = envelopeContents.type; // Type of signal that was received out of order.
             }
             this.mc.logger.sendTelemetryEvent({
                 eventName: "SignalOutOfOrder",
@@ -1981,8 +2044,8 @@ export class ContainerRuntime extends TypedEventEmitter {
                 try {
                     checkpoint.rollback((message) => this.rollback(message.contents, message.localOpMetadata));
                 }
-                catch (err) {
-                    const error2 = wrapError(err, (message) => {
+                catch (error_) {
+                    const error2 = wrapError(error_, (message) => {
                         return DataProcessingError.create(`RollbackError: ${message}`, "checkpointRollback", undefined);
                     });
                     this.closeFn(error2);
@@ -2043,15 +2106,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         return this.channelCollection.createDetachedDataStore(pkg, loadingGroupId);
     }
     async createDataStore(pkg, loadingGroupId) {
-        const context = this.channelCollection.createDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], undefined, // props
-        loadingGroupId);
-        return channelToDataStore(await context.realize(), context.id, this.channelCollection, this.mc.logger);
-    }
-    /**
-     * @deprecated 0.16 Issue #1537, #3631
-     */
-    async _createDataStoreWithProps(pkg, props) {
-        const context = this.channelCollection.createDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], props);
+        const context = this.channelCollection.createDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], loadingGroupId);
         return channelToDataStore(await context.realize(), context.id, this.channelCollection, this.mc.logger);
     }
     canSendOps() {
@@ -2078,7 +2133,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     get isDirty() {
         return this.dirtyContainer;
     }
-    isContainerMessageDirtyable({ type, contents }) {
+    isContainerMessageDirtyable({ type, contents, }) {
         // Certain container runtime messages should not mark the container dirty such as the old built-in
         // AgentScheduler and Garbage collector messages.
         switch (type) {
@@ -2101,8 +2156,9 @@ export class ContainerRuntime extends TypedEventEmitter {
             case ContainerMessageType.GC: {
                 return false;
             }
-            default:
+            default: {
                 break;
+            }
         }
         return true;
     }
@@ -2131,7 +2187,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                     clientBroadcastSignalSequenceNumber;
             }
             // We should not track the round trip of a new signal in the case we are already tracking one.
-            if (clientBroadcastSignalSequenceNumber % this.defaultTelemetrySignalSampleCount === 1 &&
+            if (clientBroadcastSignalSequenceNumber % defaultTelemetrySignalSampleCount === 1 &&
                 this._signalTracking.roundTripSignalSequenceNumber === undefined) {
                 this._signalTracking.signalTimestamp = Date.now();
                 this._signalTracking.roundTripSignalSequenceNumber =
@@ -2197,6 +2253,12 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.addContainerStateToSummary(summarizeResult, true /* fullTree */, false /* trackState */, telemetryContext);
         return summarizeResult.summary;
     }
+    /**
+     * Builds the Summary tree including all the channels and the container state.
+     *
+     * @remarks - Unfortunately, this function is accessed in a non-typesafe way by a legacy first-party partner,
+     * so until we can provide a proper API for their scenario, we need to ensure this function doesn't change.
+     */
     async summarizeInternal(fullTree, trackState, telemetryContext) {
         const summarizeResult = await this.channelCollection.summarize(fullTree, trackState, telemetryContext);
         // Wrap data store summaries in .channels subtree.
@@ -2277,8 +2339,10 @@ export class ContainerRuntime extends TypedEventEmitter {
      */
     deleteSweepReadyNodes(sweepReadyRoutes) {
         const { dataStoreRoutes, blobManagerRoutes } = this.getDataStoreAndBlobManagerRoutes(sweepReadyRoutes);
-        const deletedRoutes = this.channelCollection.deleteSweepReadyNodes(dataStoreRoutes);
-        return deletedRoutes.concat(this.blobManager.deleteSweepReadyNodes(blobManagerRoutes));
+        return [
+            ...this.channelCollection.deleteSweepReadyNodes(dataStoreRoutes),
+            ...this.blobManager.deleteSweepReadyNodes(blobManagerRoutes),
+        ];
     }
     /**
      * This is called to update objects that are tombstones.
@@ -2304,10 +2368,13 @@ export class ContainerRuntime extends TypedEventEmitter {
      * Returns the type of the GC node. Currently, there are nodes that belong to the root ("/"), data stores or
      * blob manager.
      */
+    // eslint-disable-next-line import/no-deprecated
     getNodeType(nodePath) {
         if (isBlobPath(nodePath)) {
+            // eslint-disable-next-line import/no-deprecated
             return GCNodeType.Blob;
         }
+        // eslint-disable-next-line import/no-deprecated
         return this.channelCollection.getGCNodeType(nodePath) ?? GCNodeType.Other;
     }
     /**
@@ -2321,13 +2388,19 @@ export class ContainerRuntime extends TypedEventEmitter {
             return ["_gcRoot"];
         }
         switch (this.getNodeType(nodePath)) {
-            case GCNodeType.Blob:
+            // eslint-disable-next-line import/no-deprecated
+            case GCNodeType.Blob: {
                 return [blobManagerBasePath];
+            }
+            // eslint-disable-next-line import/no-deprecated
             case GCNodeType.DataStore:
-            case GCNodeType.SubDataStore:
+            // eslint-disable-next-line import/no-deprecated
+            case GCNodeType.SubDataStore: {
                 return this.channelCollection.getDataStorePackagePath(nodePath);
-            default:
+            }
+            default: {
                 assert(false, 0x2de /* "Package path requested for unsupported node type." */);
+            }
         }
     }
     /**
@@ -2389,8 +2462,9 @@ export class ContainerRuntime extends TypedEventEmitter {
      * op processing, updating SummarizerNode state tracking, and garbage collection.
      * @param options - options controlling how the summary is generated or submitted
      */
+    // eslint-disable-next-line import/no-deprecated
     async submitSummary(options) {
-        const { fullTree = false, finalAttempt = false, summaryLogger, latestSummaryRefSeqNum, } = options;
+        const { cancellationToken, fullTree = false, finalAttempt = false, 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;
@@ -2474,7 +2548,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                     eventName: "LatestSummaryRefSeqNumMismatch",
                     details: {
                         ...startSummaryResult,
-                        mismatchNumbers: Array.from(startSummaryResult.mismatchNumbers),
+                        mismatchNumbers: [...startSummaryResult.mismatchNumbers],
                     },
                 });
                 if (shouldValidatePreSummaryState && !finalAttempt) {
@@ -2494,7 +2568,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // summarizer to reconnect in the future.
                 // Also checking for cancellation is a must as summary process may be abandoned for other reasons,
                 // like loss of connectivity for main (interactive) client.
-                if (options.cancellationToken.cancelled) {
+                if (cancellationToken.cancelled) {
                     return { continue: false, error: "disconnected" };
                 }
                 // That said, we rely on submitSystemMessage() that today only works in connected state.
@@ -2607,7 +2681,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             };
             let handle;
             try {
-                handle = await this.storage.uploadSummaryWithContext(summarizeResult.summary, summaryContext);
+                handle = await this.storage.uploadSummaryWithContext(summaryTree, summaryContext);
             }
             catch (error) {
                 return {
@@ -2729,13 +2803,13 @@ export class ContainerRuntime extends TypedEventEmitter {
         return this.pendingMessagesCount !== 0;
     }
     updateDocumentDirtyState(dirty) {
-        if (this.attachState !== AttachState.Attached) {
-            assert(dirty, 0x3d2 /* Non-attached container is dirty */);
-        }
-        else {
+        if (this.attachState === AttachState.Attached) {
             // Other way is not true = see this.isContainerMessageDirtyable()
             assert(!dirty || this.hasPendingMessages(), 0x3d3 /* if doc is dirty, there has to be pending ops */);
         }
+        else {
+            assert(dirty, 0x3d2 /* Non-attached container is dirty */);
+        }
         if (this.dirtyContainer === dirty) {
             return;
         }
@@ -2744,7 +2818,11 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.emit(dirty ? "dirty" : "saved");
         }
     }
-    submitMessage(type, contents, localOpMetadata = undefined) {
+    submitMessage(type, 
+    // TODO: better typing
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+    contents, localOpMetadata = undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         this.submit({ type, contents }, localOpMetadata);
     }
     async uploadBlob(blob, signal) {
@@ -2793,7 +2871,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             // on this callback to do actual sending.
             const schemaChangeMessage = this.documentsSchemaController.maybeSendSchemaMessage();
             if (schemaChangeMessage) {
-                this.logger.sendTelemetryEvent({
+                this.mc.logger.sendTelemetryEvent({
                     eventName: "SchemaChangeProposal",
                     refSeq: schemaChangeMessage.refSeq,
                     version: schemaChangeMessage.version,
@@ -2845,6 +2923,8 @@ export class ContainerRuntime extends TypedEventEmitter {
             return;
         }
         this.flushTaskExists = true;
+        // TODO: hoist this out of the function scope to save unnecessary allocations
+        // eslint-disable-next-line unicorn/consistent-function-scoping -- Separate `flush` method already exists in outer scope
         const flush = () => {
             this.flushTaskExists = false;
             try {
@@ -2855,22 +2935,25 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
         };
         switch (this.flushMode) {
-            case FlushMode.TurnBased:
+            case FlushMode.TurnBased: {
                 // When in TurnBased flush mode the runtime will buffer operations in the current turn and send them as a single
                 // batch at the end of the turn
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 Promise.resolve().then(flush);
                 break;
+            }
             // FlushModeExperimental is experimental and not exposed directly in the runtime APIs
-            case FlushModeExperimental.Async:
+            case FlushModeExperimental.Async: {
                 // When in Async flush mode, the runtime will accumulate all operations across JS turns and send them as a single
                 // batch when all micro-tasks are complete.
                 // Compared to TurnBased, this flush mode will capture more ops into the same batch.
                 setTimeout(flush, 0);
                 break;
-            default:
+            }
+            default: {
                 assert(this._orderSequentiallyCalls > 0, 0x587 /* Unreachable unless running under orderSequentially */);
                 break;
+            }
         }
     }
     submitSummaryMessage(contents, referenceSequenceNumber) {
@@ -2878,10 +2961,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         assert(this.connected, 0x133 /* "Container disconnected when trying to submit system message" */);
         // System message should not be sent in the middle of the batch.
         assert(this.outbox.isEmpty, 0x3d4 /* System op in the middle of a batch */);
-        // back-compat: ADO #1385: Make this call unconditional in the future
-        return this.submitSummaryFn !== undefined
-            ? this.submitSummaryFn(contents, referenceSequenceNumber)
-            : this.submitFn(MessageType.Summarize, contents, false);
+        return this.submitSummaryFn(contents, referenceSequenceNumber);
     }
     /**
      * Throw an error if the runtime is closed.  Methods that are expected to potentially
@@ -2921,15 +3001,16 @@ export class ContainerRuntime extends TypedEventEmitter {
      * @param localOpMetadata - The local metadata associated with the original message.
      */
     reSubmitCore(message, localOpMetadata, opMetadata) {
-        assert(!this.isSummarizerClient, 0x8f2 /* Summarizer never reconnects so should never resubmit */);
+        assert(this._summarizer === undefined, 0x8f2 /* Summarizer never reconnects so should never resubmit */);
         switch (message.type) {
             case ContainerMessageType.FluidDataStoreOp:
             case ContainerMessageType.Attach:
-            case ContainerMessageType.Alias:
+            case ContainerMessageType.Alias: {
                 // For Operations, call resubmitDataStoreOp which will find the right store
                 // and trigger resubmission on it.
                 this.channelCollection.reSubmit(message.type, message.contents, localOpMetadata);
                 break;
+            }
             case ContainerMessageType.IdAllocation: {
                 // Allocation ops are never resubmitted/rebased. This is because they require special handling to
                 // avoid being submitted out of order. For example, if the pending state manager contained
@@ -2940,20 +3021,24 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // all pending IDs. The resubmitted allocation ops are then ignored here.
                 break;
             }
-            case ContainerMessageType.BlobAttach:
+            case ContainerMessageType.BlobAttach: {
                 this.blobManager.reSubmit(opMetadata);
                 break;
-            case ContainerMessageType.Rejoin:
+            }
+            case ContainerMessageType.Rejoin: {
                 this.submit(message);
                 break;
-            case ContainerMessageType.GC:
+            }
+            case ContainerMessageType.GC: {
                 this.submit(message);
                 break;
-            case ContainerMessageType.DocumentSchemaChange:
+            }
+            case ContainerMessageType.DocumentSchemaChange: {
                 // There is no need to resend this message. Document schema controller will properly resend it again (if needed)
                 // on a first occasion (any ops sent after reconnect). There is a good chance, though, that it will not want to
                 // send any ops, as some other client already changed schema.
                 break;
+            }
             default: {
                 const error = getUnknownMessageTypeError(message.type, "reSubmitCore" /* codePath */);
                 this.closeFn(error);
@@ -2965,16 +3050,21 @@ export class ContainerRuntime extends TypedEventEmitter {
         // Need to parse from string for back-compat
         const { type, contents } = this.parseLocalOpContent(content);
         switch (type) {
-            case ContainerMessageType.FluidDataStoreOp:
+            case ContainerMessageType.FluidDataStoreOp: {
                 // For operations, call rollbackDataStoreOp which will find the right store
                 // and trigger rollback on it.
                 this.channelCollection.rollback(type, contents, localOpMetadata);
                 break;
-            default:
+            }
+            default: {
                 throw new Error(`Can't rollback ${type}`);
+            }
         }
     }
-    /** Implementation of ISummarizerInternalsProvider.refreshLatestSummaryAck */
+    /**
+     * Implementation of ISummarizerInternalsProvider.refreshLatestSummaryAck
+     */
+    // eslint-disable-next-line import/no-deprecated
     async refreshLatestSummaryAck(options) {
         const { proposalHandle, ackHandle, summaryRefSeq, summaryLogger } = options;
         // proposalHandle is always passed from RunningSummarizer.
@@ -3044,15 +3134,16 @@ export class ContainerRuntime extends TypedEventEmitter {
                 snapshotTree = snapshot.snapshotTree;
             }
             else {
-                const versions = await this.storage.getVersions(null, 1, scenarioName, FetchSource.noCache);
+                const versions = await this.storage.getVersions(
+                // eslint-disable-next-line unicorn/no-null
+                null, 1, scenarioName, FetchSource.noCache);
                 assert(!!versions && !!versions[0], 0x137 /* "Failed to get version from storage" */);
                 snapshotTree = await this.storage.getSnapshotTree(versions[0]);
                 assert(!!snapshotTree, 0x138 /* "Failed to get snapshot from storage" */);
                 props.snapshotVersion = versions[0].id;
             }
             props.getSnapshotDuration = trace.trace().duration;
-            const readAndParseBlob = async (id) => readAndParse(this.storage, id);
-            const snapshotRefSeq = await seqFromTree(snapshotTree, readAndParseBlob);
+            const snapshotRefSeq = await seqFromTree(snapshotTree, this.readAndParseBlob);
             props.snapshotRefSeq = snapshotRefSeq;
             props.newerSnapshotPresent = snapshotRefSeq >= targetRefSeq;
             perfEvent.end({ details: props });
@@ -3105,32 +3196,32 @@ export class ContainerRuntime extends TypedEventEmitter {
             : PerformanceEvent.timedExec(this.mc.logger, perfEvent, (event) => logAndReturnPendingState(event, getSyncState()));
     }
     summarizeOnDemand(options) {
-        if (this.isSummarizerClient) {
-            return this.summarizer.summarizeOnDemand(options);
+        if (this._summarizer !== undefined) {
+            return this._summarizer.summarizeOnDemand(options);
         }
-        else if (this.summaryManager !== undefined) {
-            return this.summaryManager.summarizeOnDemand(options);
-        }
-        else {
+        else if (this.summaryManager === undefined) {
             // If we're not the summarizer, and we don't have a summaryManager, we expect that
             // disableSummaries is turned on. We are throwing instead of returning a failure here,
             // because it is a misuse of the API rather than an expected failure.
             throw new UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
         }
+        else {
+            return this.summaryManager.summarizeOnDemand(options);
+        }
     }
     enqueueSummarize(options) {
-        if (this.isSummarizerClient) {
-            return this.summarizer.enqueueSummarize(options);
-        }
-        else if (this.summaryManager !== undefined) {
-            return this.summaryManager.enqueueSummarize(options);
+        if (this._summarizer !== undefined) {
+            return this._summarizer.enqueueSummarize(options);
         }
-        else {
+        else if (this.summaryManager === undefined) {
             // If we're not the summarizer, and we don't have a summaryManager, we expect that
             // generateSummaries is turned off. We are throwing instead of returning a failure here,
             // because it is a misuse of the API rather than an expected failure.
             throw new UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
         }
+        else {
+            return this.summaryManager.enqueueSummarize(options);
+        }
     }
     /**
      * Forms a function that will create and retrieve a Summarizer.