@fluidframework/container-runtime 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

package/dist/containerRuntime.js

@@ -1,32 +1,37 @@
 "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.DefaultSummaryConfiguration = void 0;
-const container_definitions_1 = require("@fluidframework/container-definitions");
-const core_utils_1 = require("@fluidframework/core-utils");
+exports.ContainerRuntime = exports.makeLegacySendBatchFn = exports.getDeviceSpec = exports.agentSchedulerId = exports.isRuntimeMessage = exports.defaultPendingOpsRetryDelayMs = exports.defaultPendingOpsWaitTimeoutMs = exports.disabledCompressionConfig = exports.CompressionAlgorithms = exports.defaultRuntimeHeaderData = exports.InactiveResponseHeaderKey = exports.TombstoneResponseHeaderKey = exports.DefaultSummaryConfiguration = void 0;
 const client_utils_1 = require("@fluid-internal/client-utils");
-const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
-const driver_definitions_1 = require("@fluidframework/driver-definitions");
-const driver_utils_1 = require("@fluidframework/driver-utils");
+const container_definitions_1 = require("@fluidframework/container-definitions");
+const internal_1 = require("@fluidframework/container-definitions/internal");
+const internal_2 = require("@fluidframework/core-utils/internal");
+const internal_3 = require("@fluidframework/driver-definitions/internal");
+const internal_4 = require("@fluidframework/driver-utils/internal");
 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 internal_5 = require("@fluidframework/runtime-definitions/internal");
+const internal_6 = require("@fluidframework/runtime-utils/internal");
+const internal_7 = require("@fluidframework/telemetry-utils/internal");
 const uuid_1 = require("uuid");
-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 batchTracker_js_1 = require("./batchTracker.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 connectionTelemetry_js_1 = require("./connectionTelemetry.js");
+const containerHandleContext_js_1 = require("./containerHandleContext.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 dataStoreRegistry_js_1 = require("./dataStoreRegistry.js");
 const deltaManagerSummarizerProxy_js_1 = require("./deltaManagerSummarizerProxy.js");
+const index_js_1 = require("./gc/index.js");
 const messageTypes_js_1 = require("./messageTypes.js");
+const index_js_2 = require("./opLifecycle/index.js");
+const packageVersion_js_1 = require("./packageVersion.js");
+const pendingStateManager_js_1 = require("./pendingStateManager.js");
+const scheduleManager_js_1 = require("./scheduleManager.js");
+const index_js_3 = require("./summary/index.js");
+const throttler_js_1 = require("./throttler.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
@@ -81,8 +86,13 @@ var CompressionAlgorithms;
 (function (CompressionAlgorithms) {
     CompressionAlgorithms["lz4"] = "lz4";
 })(CompressionAlgorithms || (exports.CompressionAlgorithms = CompressionAlgorithms = {}));
+/** @alpha */
+exports.disabledCompressionConfig = {
+    minimumBatchSizeInBytes: Infinity,
+    compressionAlgorithm: CompressionAlgorithms.lz4,
+};
 const maxConsecutiveReconnectsKey = "Fluid.ContainerRuntime.MaxConsecutiveReconnects";
-const defaultFlushMode = runtime_definitions_1.FlushMode.TurnBased;
+const defaultFlushMode = internal_5.FlushMode.TurnBased;
 // The actual limit is 1Mb (socket.io and Kafka limits)
 // We can't estimate it fully, as we
 // - do not know what properties relay service will add
@@ -104,26 +114,12 @@ exports.defaultPendingOpsRetryDelayMs = 1000;
  * This delay's goal is to prevent tight restart loops
  */
 const defaultCloseSummarizerDelayMs = 5000; // 5 seconds
-/**
- * @deprecated use ContainerRuntimeMessageType instead
- * @internal
- */
-var RuntimeMessage;
-(function (RuntimeMessage) {
-    RuntimeMessage["FluidDataStoreOp"] = "component";
-    RuntimeMessage["Attach"] = "attach";
-    RuntimeMessage["ChunkedOp"] = "chunkedOp";
-    RuntimeMessage["BlobAttach"] = "blobAttach";
-    RuntimeMessage["Rejoin"] = "rejoin";
-    RuntimeMessage["Alias"] = "alias";
-    RuntimeMessage["Operation"] = "op";
-})(RuntimeMessage || (exports.RuntimeMessage = RuntimeMessage = {}));
 /**
  * @deprecated please use version in driver-utils
  * @internal
  */
 function isRuntimeMessage(message) {
-    return Object.values(RuntimeMessage).includes(message.type);
+    return Object.values(messageTypes_js_1.ContainerMessageType).includes(message.type);
 }
 exports.isRuntimeMessage = isRuntimeMessage;
 /**
@@ -169,13 +165,13 @@ const summarizerRequestUrl = "_summarizer";
 async function createSummarizer(loader, url) {
     const request = {
         headers: {
-            [container_definitions_1.LoaderHeader.cache]: false,
-            [container_definitions_1.LoaderHeader.clientDetails]: {
+            [internal_1.LoaderHeader.cache]: false,
+            [internal_1.LoaderHeader.clientDetails]: {
                 capabilities: { interactive: false },
-                type: index_js_1.summarizerClientType,
+                type: index_js_3.summarizerClientType,
             },
-            [driver_definitions_1.DriverHeader.summarizingClient]: true,
-            [container_definitions_1.LoaderHeader.reconnect]: false,
+            [internal_3.DriverHeader.summarizingClient]: true,
+            [internal_1.LoaderHeader.reconnect]: false,
         },
         url,
     };
@@ -191,15 +187,26 @@ async function createSummarizer(loader, url) {
             url: `/${summarizerRequestUrl}`,
         });
         if (response.status !== 200 || response.mimeType !== "fluid/object") {
-            throw (0, runtime_utils_1.responseToException)(response, request);
+            throw (0, internal_6.responseToException)(response, request);
         }
         fluidObject = response.value;
     }
     if (fluidObject?.ISummarizer === undefined) {
-        throw new telemetry_utils_1.UsageError("Fluid object does not implement ISummarizer");
+        throw new internal_7.UsageError("Fluid object does not implement ISummarizer");
     }
     return fluidObject.ISummarizer;
 }
+/**
+ * Extract last message from the snapshot metadata.
+ * Uses legacy property if not using explicit schema control, otherwise uses the new property.
+ * 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) {
+    return metadata?.documentSchema?.runtime?.explicitSchemaControl
+        ? metadata?.lastMessage
+        : metadata?.message;
+}
 /**
  * Represents the runtime of the container. Contains helper functions/state of the container.
  * It will define the store level mappings.
@@ -227,8 +234,9 @@ 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 ??
-            new telemetry_utils_1.TaggedLoggerAdapter(backCompatContext.logger);
-        const logger = (0, telemetry_utils_1.createChildLogger)({
+            // eslint-disable-next-line import/no-deprecated
+            new internal_7.TaggedLoggerAdapter(backCompatContext.logger);
+        const logger = (0, internal_7.createChildLogger)({
             logger: passLogger,
             properties: {
                 all: {
@@ -236,42 +244,49 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 },
             },
         });
-        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 mc = (0, internal_7.loggerToMonitoringContext)(logger);
+        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, compressionOptions = defaultCompressionConfig, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, enableRuntimeIdCompressor, chunkSizeInBytes = defaultChunkSizeInBytes, enableOpReentryCheck = false, enableGroupedBatching = false, explicitSchemaControl = false, } = runtimeOptions;
         const registry = new dataStoreRegistry_js_1.FluidDataStoreRegistry(registryEntries);
         const tryFetchBlob = async (blobName) => {
             const blobId = context.baseSnapshot?.blobs[blobName];
             if (context.baseSnapshot && blobId) {
                 // 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, 0x1f5 /* "Attached state should have storage" */);
-                return (0, driver_utils_1.readAndParse)(context.storage, blobId);
+                (0, internal_2.assert)(context.storage !== undefined, 0x1f5 /* "Attached state should have storage" */);
+                return (0, internal_4.readAndParse)(context.storage, blobId);
             }
         };
         const [chunks, metadata, electedSummarizerData, aliases, serializedIdCompressor] = await Promise.all([
-            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),
+            tryFetchBlob(index_js_3.chunksBlobName),
+            tryFetchBlob(index_js_3.metadataBlobName),
+            tryFetchBlob(index_js_3.electedSummarizerBlobName),
+            tryFetchBlob(index_js_3.aliasBlobName),
+            tryFetchBlob(index_js_3.idCompressorBlobName),
         ]);
         // read snapshot blobs needed for BlobManager to load
-        const blobManagerSnapshot = await blobManager_js_1.BlobManager.load(context.baseSnapshot?.trees[index_js_1.blobsTreeName], async (id) => {
+        const blobManagerSnapshot = await blobManager_js_1.BlobManager.load(context.baseSnapshot?.trees[index_js_3.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" */);
-            return (0, driver_utils_1.readAndParse)(context.storage, id);
+            (0, internal_2.assert)(context.storage !== undefined, 0x256 /* "storage undefined in attached container" */);
+            return (0, internal_4.readAndParse)(context.storage, id);
         });
+        const messageAtLastSummary = lastMessageFromMetadata(metadata);
         // Verify summary runtime sequence number matches protocol sequence number.
-        const runtimeSequenceNumber = metadata?.message?.sequenceNumber;
+        const runtimeSequenceNumber = messageAtLastSummary?.sequenceNumber;
         // 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) {
             const protocolSequenceNumber = context.deltaManager.initialSequenceNumber;
             // Unless bypass is explicitly set, then take action when sequence numbers mismatch.
             if (loadSequenceNumberVerification !== "bypass" &&
                 runtimeSequenceNumber !== protocolSequenceNumber) {
+                // Message to OCEs:
+                // You can hit this error with runtimeSequenceNumber === -1 in < 2.0 RC3 builds.
+                // This would indicate that explicit schema control is enabled in current (2.0 RC3+) builds and it
+                // results in addMetadataToSummary() creating a poison pill for older runtimes in the form of a -1 sequence number.
+                // Older runtimes do not understand new schema, and thus could corrupt document if they proceed, thus we are using
+                // this poison pill to prevent them from proceeding.
                 // "Load from summary, runtime metadata sequenceNumber !== initialSequenceNumber"
-                const error = new telemetry_utils_1.DataCorruptionError(
+                const error = new internal_7.DataCorruptionError(
                 // pre-0.58 error message: SummaryMetadataMismatch
                 "Summary metadata mismatch", { runtimeVersion: packageVersion_js_1.pkgVersion, runtimeSequenceNumber, protocolSequenceNumber });
                 if (loadSequenceNumberVerification === "log") {
@@ -282,8 +297,20 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 }
             }
         }
+        let desiredIdCompressorMode;
+        switch (mc.config.getBoolean("Fluid.ContainerRuntime.IdCompressorEnabled")) {
+            case true:
+                desiredIdCompressorMode = "on";
+                break;
+            case false:
+                desiredIdCompressorMode = undefined;
+                break;
+            default:
+                desiredIdCompressorMode = enableRuntimeIdCompressor;
+                break;
+        }
         // Enabling the IdCompressor is a one-way operation and we only want to
-        // allow new containers to turn it on
+        // allow new containers to turn it on.
         let idCompressorMode;
         if (existing) {
             // This setting has to be sticky for correctness:
@@ -292,28 +319,30 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             // 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.
+            // We could do "off" -> "on" transition too, if all clients start loading compressor (but not using it initially) and
+            // do so for a while - this will allow clients to eventually 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";
+            idCompressorMode = metadata?.documentSchema?.runtime
+                ?.idCompressorMode;
+            // This is the only exception to the rule above - we have proper plumbing to load ID compressor on schema change
+            // event. It is loaded async (relative to op processing), so this conversion is only safe for off -> delayed conversion!
+            // Clients do not expect ID compressor ops unless ID compressor is On for them, and that could be achieved only through
+            // explicit schema change, i.e. only if explicitSchemaControl is on.
+            // Note: it would be better if we throw on combination of options (explicitSchemaControl = off, desiredIdCompressorMode === "delayed")
+            // that is not supported. But our service tests are oblivious to these problems and throwing here will cause a ton of failures
+            // We ignored incompatible ID compressor changes from the start (they were sticky), so that's not a new problem being introduced...
+            if (idCompressorMode === undefined &&
+                desiredIdCompressorMode === "delayed" &&
+                explicitSchemaControl) {
+                idCompressorMode = desiredIdCompressorMode;
+            }
         }
         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;
-            }
+            idCompressorMode = desiredIdCompressorMode;
         }
         const createIdCompressorFn = async () => {
-            const { createIdCompressor, deserializeIdCompressor, createSessionId } = await import("@fluidframework/id-compressor");
+            const { createIdCompressor, deserializeIdCompressor, createSessionId } = await import("@fluidframework/id-compressor/internal");
             /**
              * Because the IdCompressor emits so much telemetry, this function is used to sample
              * approximately 5% of all clients. Only the given percentage of sessions will emit telemetry.
@@ -326,7 +355,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                     },
                 };
             })();
-            const compressorLogger = (0, telemetry_utils_1.createSampledLogger)(logger, idCompressorEventSampler);
+            const compressorLogger = (0, internal_7.createSampledLogger)(logger, idCompressorEventSampler);
             const pendingLocalState = context.pendingLocalState;
             if (pendingLocalState?.pendingIdCompressorState !== undefined) {
                 return deserializeIdCompressor(pendingLocalState.pendingIdCompressorState, compressorLogger);
@@ -338,6 +367,25 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 return createIdCompressor(compressorLogger);
             }
         };
+        const disableGroupedBatching = mc.config.getBoolean("Fluid.ContainerRuntime.DisableGroupedBatching");
+        const disableCompression = mc.config.getBoolean("Fluid.ContainerRuntime.CompressionDisabled");
+        const compressionLz4 = disableCompression !== true &&
+            compressionOptions.minimumBatchSizeInBytes !== Infinity &&
+            compressionOptions.compressionAlgorithm === "lz4";
+        const opGroupingEnabled = disableGroupedBatching !== true && enableGroupedBatching;
+        const documentSchemaController = new index_js_3.DocumentsSchemaController(existing, metadata?.documentSchema, {
+            explicitSchemaControl,
+            compressionLz4,
+            idCompressorMode,
+            opGroupingEnabled,
+            disallowedVersions: [],
+        }, (schema) => {
+            runtime.onSchemaChange(schema);
+        });
+        const featureGatesForTelemetry = {
+            disableGroupedBatching,
+            disableCompression,
+        };
         const runtime = new containerRuntimeCtor(context, registry, metadata, electedSummarizerData, chunks ?? [], aliases ?? [], {
             summaryOptions,
             gcOptions,
@@ -346,10 +394,19 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             compressionOptions,
             maxBatchSizeInBytes,
             chunkSizeInBytes,
-            enableRuntimeIdCompressor,
+            // Requires<> drops undefined from IdCompressorType
+            enableRuntimeIdCompressor: enableRuntimeIdCompressor,
             enableOpReentryCheck,
             enableGroupedBatching,
-        }, containerScope, logger, existing, blobManagerSnapshot, context.storage, createIdCompressorFn, idCompressorMode, provideEntryPoint, requestHandler, undefined);
+            explicitSchemaControl,
+        }, containerScope, logger, existing, blobManagerSnapshot, context.storage, createIdCompressorFn, documentSchemaController, featureGatesForTelemetry, provideEntryPoint, requestHandler, undefined);
+        runtime.blobManager.trackPendingStashedUploads().then(() => {
+            // make sure we didn't reconnect before the promise resolved
+            if (runtime.delayConnectClientId !== undefined && !runtime.disposed) {
+                runtime.delayConnectClientId = undefined;
+                runtime.setConnectionStateCore(true, runtime.delayConnectClientId);
+            }
+        }, (error) => runtime.closeFn(error));
         // 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);
@@ -378,6 +435,12 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     get attachState() {
         return this._getAttachState();
     }
+    get documentSchema() {
+        return this.documentsSchemaController.sessionSchema.runtime;
+    }
+    get idCompressorMode() {
+        return this.documentSchema.idCompressorMode;
+    }
     /**
      * See IContainerRuntimeBase.idCompressor() for details.
      */
@@ -387,7 +450,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // 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 */);
+            (0, internal_2.assert)(this._idCompressor !== undefined, 0x8ea /* compressor should have been loaded */);
             return this._idCompressor;
         }
     }
@@ -428,7 +491,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         return this._disposed;
     }
     get summarizer() {
-        (0, core_utils_1.assert)(this._summarizer !== undefined, 0x257 /* "This is not summarizing container" */);
+        (0, internal_2.assert)(this._summarizer !== undefined, 0x257 /* "This is not summarizing container" */);
         return this._summarizer;
     }
     isSummariesDisabled() {
@@ -458,7 +521,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, createIdCompressor, idCompressorMode, provideEntryPoint, requestHandler, summaryConfiguration = {
+    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, createIdCompressor, documentsSchemaController, featureGatesForTelemetry, provideEntryPoint, requestHandler, summaryConfiguration = {
         // the defaults
         ...exports.DefaultSummaryConfiguration,
         // the runtime configuration overrides
@@ -472,18 +535,13 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         this.logger = logger;
         this._storage = _storage;
         this.createIdCompressor = createIdCompressor;
-        this.idCompressorMode = idCompressorMode;
+        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 = [];
-        /**
-         * 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;
@@ -509,10 +567,24 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
          * 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({
+        this.snapshotCacheForLoadingGroupIds = new internal_2.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.mc = (0, internal_7.createChildMonitoringContext)({
+            logger: this.logger,
+            namespace: "ContainerRuntime",
+        });
+        // If we support multiple algorithms in the future, then we would need to manage it here carefully.
+        // We can use runtimeOptions.compressionOptions.compressionAlgorithm, but only if it's in the schema list!
+        // If it's not in the list, then we will need to either use no compression, or fallback to some other (supported by format)
+        // compression.
+        const compressionOptions = {
+            minimumBatchSizeInBytes: this.documentSchema.compressionLz4
+                ? runtimeOptions.compressionOptions.minimumBatchSizeInBytes
+                : Number.POSITIVE_INFINITY,
+            compressionAlgorithm: CompressionAlgorithms.lz4,
+        };
         this.innerDeltaManager = deltaManager;
         this.deltaManager = new deltaManagerSummarizerProxy_js_1.DeltaManagerSummarizerProxy(this.innerDeltaManager);
         // Here we could wrap/intercept on these functions to block/modify outgoing messages if needed.
@@ -525,7 +597,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // Values are generally expected to be set from the runtime side.
         this.options = options ?? {};
         this.clientDetails = clientDetails;
-        this.isSummarizerClient = this.clientDetails.type === index_js_1.summarizerClientType;
+        this.isSummarizerClient = this.clientDetails.type === index_js_3.summarizerClientType;
         this.loadedFromVersionId = context.getLoadedFromVersion()?.id;
         this._getClientId = () => context.clientId;
         this._getAttachState = () => context.attachState;
@@ -546,10 +618,6 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         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.mc = (0, telemetry_utils_1.createChildMonitoringContext)({
-            logger: this.logger,
-            namespace: "ContainerRuntime",
-        });
         let loadSummaryNumber;
         // Get the container creation metadata. For new container, we initialize these. For existing containers,
         // get the values from the metadata blob.
@@ -570,7 +638,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             loadSummaryNumber = 0;
         }
         this.nextSummaryNumber = loadSummaryNumber + 1;
-        this.messageAtLastSummary = metadata?.message;
+        this.messageAtLastSummary = lastMessageFromMetadata(metadata);
         // Note that we only need to pull the *initial* connected state from the context.
         // Later updates come through calls to setConnectionState.
         this._connected = connected;
@@ -578,20 +646,20 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             eventName: "GCFeatureMatrix",
             metadataValue: JSON.stringify(metadata?.gcFeatureMatrix),
             inputs: JSON.stringify({
-                gcOptions_gcGeneration: this.runtimeOptions.gcOptions[index_js_2.gcGenerationOptionName],
+                gcOptions_gcGeneration: this.runtimeOptions.gcOptions[index_js_1.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 index_js_3.OpGroupingManager({
+        const opGroupingManager = new index_js_2.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 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);
+        const opSplitter = new index_js_2.OpSplitter(chunks, this.submitBatchFn, disableChunking === true ? Number.POSITIVE_INFINITY : runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger);
+        this.remoteMessageProcessor = new index_js_2.RemoteMessageProcessor(opSplitter, new index_js_2.OpDecompressor(this.mc.logger), opGroupingManager);
         this.handleContext = new containerHandleContext_js_1.ContainerFluidHandleContext("", this);
         if (this.summaryConfiguration.state === "enabled") {
             this.validateSummaryHeuristicConfiguration(this.summaryConfiguration);
@@ -607,11 +675,11 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         this.maxConsecutiveReconnects =
             this.mc.config.getNumber(maxConsecutiveReconnectsKey) ??
                 this.defaultMaxConsecutiveReconnects;
-        if (runtimeOptions.flushMode === runtime_definitions_1.FlushModeExperimental.Async &&
+        if (runtimeOptions.flushMode === internal_5.FlushModeExperimental.Async &&
             supportedFeatures?.get("referenceSequenceNumbers") !== true) {
             // The loader does not support reference sequence numbers, falling back on FlushMode.TurnBased
             this.mc.logger.sendErrorEvent({ eventName: "FlushModeFallback" });
-            this._flushMode = runtime_definitions_1.FlushMode.TurnBased;
+            this._flushMode = internal_5.FlushMode.TurnBased;
         }
         else {
             this._flushMode = runtimeOptions.flushMode;
@@ -624,10 +692,10 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 // This is a runtime enforcement of what's already explicit in the policy's type itself,
                 // which dictates the value is either undefined or exactly 5 days in ms.
                 // As long as the actual value is less than 5 days, the assumptions GC makes here are valid.
-                throw new telemetry_utils_1.UsageError("Driver's maximumCacheDurationMs policy cannot exceed 5 days");
+                throw new internal_7.UsageError("Driver's maximumCacheDurationMs policy cannot exceed 5 days");
             }
         }
-        this.garbageCollector = index_js_2.GarbageCollector.create({
+        this.garbageCollector = index_js_1.GarbageCollector.create({
             runtime: this,
             gcOptions: this.runtimeOptions.gcOptions,
             baseSnapshot,
@@ -638,12 +706,12 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             isSummarizerClient: this.isSummarizerClient,
             getNodePackagePath: async (nodePath) => this.getGCNodePackagePath(nodePath),
             getLastSummaryTimestampMs: () => this.messageAtLastSummary?.timestamp,
-            readAndParseBlob: async (id) => (0, driver_utils_1.readAndParse)(this.storage, id),
+            readAndParseBlob: async (id) => (0, internal_4.readAndParse)(this.storage, id),
             submitMessage: (message) => this.submit(message),
             sessionExpiryTimerStarted: pendingRuntimeState?.sessionExpiryTimerStarted,
         });
         const loadedFromSequenceNumber = this.deltaManager.initialSequenceNumber;
-        this.summarizerNode = (0, index_js_1.createRootSummarizerNodeWithGC)((0, telemetry_utils_1.createChildLogger)({ logger: this.logger, namespace: "SummarizerNode" }), 
+        this.summarizerNode = (0, index_js_3.createRootSummarizerNodeWithGC)((0, internal_7.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
@@ -673,40 +741,46 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             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_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_js_1.ScheduleManager(this.innerDeltaManager, this, () => this.clientId, (0, telemetry_utils_1.createChildLogger)({ logger: this.logger, namespace: "ScheduleManager" }));
+        this.blobManager = new blobManager_js_1.BlobManager({
+            routeContext: this.handleContext,
+            snapshot: blobManagerSnapshot,
+            getStorage: () => this.storage,
+            sendBlobAttachOp: (localId, blobId) => {
+                if (!this.disposed) {
+                    this.submit({ type: messageTypes_js_1.ContainerMessageType.BlobAttach, contents: undefined }, undefined, {
+                        localId,
+                        blobId,
+                    });
+                }
+            },
+            blobRequested: (blobPath) => this.garbageCollector.nodeUpdated(blobPath, "Loaded"),
+            isBlobDeleted: (blobPath) => this.garbageCollector.isNodeDeleted(blobPath),
+            runtime: this,
+            stashedBlobs: pendingRuntimeState?.pendingAttachmentBlobs,
+            closeContainer: (error) => this.closeFn(error),
+        });
+        this.scheduleManager = new scheduleManager_js_1.ScheduleManager(this.innerDeltaManager, this, () => this.clientId, (0, internal_7.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
-            ? {
-                minimumBatchSizeInBytes: Number.POSITIVE_INFINITY,
-                compressionAlgorithm: CompressionAlgorithms.lz4,
-            }
-            : runtimeOptions.compressionOptions;
         const disablePartialFlush = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisablePartialFlush");
         const legacySendBatchFn = (0, exports.makeLegacySendBatchFn)(this.submitFn, this.innerDeltaManager);
-        this.outbox = new index_js_3.Outbox({
+        this.outbox = new index_js_2.Outbox({
             shouldSend: () => this.canSendOps(),
             pendingStateManager: this.pendingStateManager,
             submitBatchFn: this.submitBatchFn,
             legacySendBatchFn,
-            compressor: new index_js_3.OpCompressor(this.mc.logger),
+            compressor: new index_js_2.OpCompressor(this.mc.logger),
             splitter: opSplitter,
             config: {
                 compressionOptions,
@@ -733,7 +807,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 index_js_1.SummaryCollection(this.deltaManager, this.logger);
+        this.summaryCollection = new index_js_3.SummaryCollection(this.deltaManager, this.logger);
         this.dirtyContainer =
             this.attachState !== container_definitions_1.AttachState.Attached || this.hasPendingMessages();
         context.updateDirtyContainerState(this.dirtyContainer);
@@ -741,20 +815,20 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             this.mc.logger.sendTelemetryEvent({ eventName: "SummariesDisabled" });
         }
         else {
-            const orderedClientLogger = (0, telemetry_utils_1.createChildLogger)({
+            const orderedClientLogger = (0, internal_7.createChildLogger)({
                 logger: this.logger,
                 namespace: "OrderedClientElection",
             });
-            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);
+            const orderedClientCollection = new index_js_3.OrderedClientCollection(orderedClientLogger, this.innerDeltaManager, this._quorum);
+            const orderedClientElectionForSummarizer = new index_js_3.OrderedClientElection(orderedClientLogger, orderedClientCollection, electedSummarizerData ?? this.innerDeltaManager.lastSequenceNumber, index_js_3.SummarizerClientElection.isClientEligible);
+            this.summarizerClientElection = new index_js_3.SummarizerClientElection(orderedClientLogger, this.summaryCollection, orderedClientElectionForSummarizer, this.maxOpsSinceLastSummary);
             if (this.isSummarizerClient) {
-                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, 
+                this._summarizer = new index_js_3.Summarizer(this /* ISummarizerRuntime */, () => this.summaryConfiguration, this /* ISummarizerInternalsProvider */, this.handleContext, this.summaryCollection, async (runtime) => index_js_3.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 (index_js_1.SummarizerClientElection.clientDetailsPermitElection(this.clientDetails)) {
+            else if (index_js_3.SummarizerClientElection.clientDetailsPermitElection(this.clientDetails)) {
                 // Only create a SummaryManager and SummarizerClientElection
                 // if summaries are enabled and we are not the summarizer client.
                 const defaultAction = () => {
@@ -776,7 +850,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 };
                 this.summaryCollection.on("default", defaultAction);
                 // Create the SummaryManager and mark the initial state
-                this.summaryManager = new index_js_1.SummaryManager(this.summarizerClientElection, this, // IConnectedState
+                this.summaryManager = new index_js_3.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)
@@ -803,10 +877,10 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             disableIsolatedChannels: metadata?.disableIsolatedChannels,
             gcVersion: metadata?.gcFeature,
             options: JSON.stringify(runtimeOptions),
-            idCompressorModeMetadata: metadata?.idCompressorMode,
+            idCompressorModeMetadata: metadata?.documentSchema?.runtime?.idCompressorMode,
             idCompressorMode: this.idCompressorMode,
             featureGates: JSON.stringify({
-                disableCompression,
+                ...featureGatesForTelemetry,
                 disableOpReentryCheck,
                 disableChunking,
                 disableAttachReorder: this.disableAttachReorder,
@@ -818,9 +892,9 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         });
         (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 () => {
+        this.entryPoint = new internal_2.LazyPromise(async () => {
             if (this.isSummarizerClient) {
-                (0, core_utils_1.assert)(this._summarizer !== undefined, 0x5bf /* Summarizer object is undefined in a summarizer client */);
+                (0, internal_2.assert)(this._summarizer !== undefined, 0x5bf /* Summarizer object is undefined in a summarizer client */);
                 return this._summarizer;
             }
             return provideEntryPoint(this);
@@ -829,14 +903,32 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // saved state, i.e. all the ops marked by Loader layer sa savedOp === true.
         this.skipSavedCompressorOps = pendingRuntimeState?.pendingIdCompressorState !== undefined;
     }
+    onSchemaChange(schema) {
+        // Most of the settings will be picked up only by new sessions (i.e. after reload).
+        // We can make it better in the future (i.e. start to use op compression right away), but for simplicity
+        // this is not done.
+        // But ID compressor is special. It's possible, that in future, we will remove "stickiness" of ID compressor setting
+        // and will allow to start using it. If that were to happen, we want to ensure that we do not break eventual consistency
+        // promises. To do so, we need to initialize id compressor right away.
+        // As it's implemented right now (with async initialization), this will only work for "off" -> "delayed" transitions.
+        // Anything else is too risky, and requires ability to initialize ID compressor synchronously!
+        if (schema.runtime.idCompressorMode !== undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            this.loadIdCompressor();
+        }
+    }
     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 */);
+        (0, internal_2.assert)(false, 0x8eb /* should not be called */);
+    }
+    setChannelDirty(address) {
+        (0, internal_2.assert)(false, 0x909 /* should not be called */);
     }
     /**
      * Initializes the state from the base snapshot this container runtime loaded from.
@@ -845,7 +937,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         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 */);
+            (0, internal_2.assert)(this.pendingIdCompressorOps.length === 0, 0x8ec /* no pending ops */);
             this._idCompressor = await this.createIdCompressor();
         }
         await this.garbageCollector.initializeBaseState();
@@ -879,13 +971,13 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      */
     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 */);
+        (0, internal_2.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 */);
+            (0, internal_2.assert)(this.storage.getSnapshot !== undefined, 0x8ee /* getSnapshot api should be defined if used */);
             loadedFromCache = false;
             return this.storage.getSnapshot({
                 cacheSnapshot: false,
@@ -901,16 +993,16 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             }),
         });
         // 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 hasIsolatedChannels = (0, index_js_3.rootHasIsolatedChannels)(this.metadata);
         const snapshotTreeForPath = this.getSnapshotTreeForPath(snapshot.snapshotTree, pathParts, hasIsolatedChannels);
-        (0, core_utils_1.assert)(snapshotTreeForPath !== undefined, 0x8ef /* no snapshotTree for the path */);
+        (0, internal_2.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 */);
+        (0, internal_2.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, {
+            throw internal_7.DataProcessingError.create("Downloaded snapshot older than snapshot we loaded from", "getSnapshotForLoadingGroupId", undefined, {
                 loadingGroupIds: sortedLoadingGroupIds.join(","),
                 snapshotSeqNumber,
                 initialSequenceNumber: this.deltaManager.initialSequenceNumber,
@@ -933,7 +1025,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 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, {
+            const event = internal_7.PerformanceEvent.start(this.mc.logger, {
                 ...props,
             });
             // If the inbound deltas queue is paused or disconnected, we expect a reconnect and unpause
@@ -941,7 +1033,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             if (this.deltaManager.inbound.paused) {
                 props.inboundPaused = this.deltaManager.inbound.paused; // reusing telemetry
             }
-            const defP = new core_utils_1.Deferred();
+            const defP = new internal_2.Deferred();
             this.deltaManager.on("op", (message) => {
                 if (message.sequenceNumber >= snapshotSeqNumber) {
                     defP.resolve(true);
@@ -964,7 +1056,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         let childTree = snapshotTree;
         for (const part of pathParts) {
             if (hasIsolatedChannels) {
-                childTree = childTree?.trees[runtime_definitions_1.channelsTreeName];
+                childTree = childTree?.trees[internal_5.channelsTreeName];
             }
             childTree = childTree?.trees[part];
         }
@@ -978,7 +1070,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     // @ts-expect-error expected to be used by LTS Loaders and Containers
     async request(request) {
         try {
-            const parser = runtime_utils_1.RequestParser.create(request);
+            const parser = internal_6.RequestParser.create(request);
             const id = parser.pathParts[0];
             if (id === summarizerRequestUrl && parser.pathParts.length === 1) {
                 if (this._summarizer !== undefined) {
@@ -988,16 +1080,16 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                         value: this.summarizer,
                     };
                 }
-                return (0, runtime_utils_1.create404Response)(request);
+                return (0, internal_6.create404Response)(request);
             }
             if (this.requestHandler !== undefined) {
                 // eslint-disable-next-line @typescript-eslint/return-await -- Adding an await here causes test failures
                 return this.requestHandler(parser, this);
             }
-            return (0, runtime_utils_1.create404Response)(request);
+            return (0, internal_6.create404Response)(request);
         }
         catch (error) {
-            return (0, runtime_utils_1.exceptionToResponse)(error);
+            return (0, internal_6.exceptionToResponse)(error);
         }
     }
     /**
@@ -1006,7 +1098,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      */
     async resolveHandle(request) {
         try {
-            const requestParser = runtime_utils_1.RequestParser.create(request);
+            const requestParser = internal_6.RequestParser.create(request);
             const id = requestParser.pathParts[0];
             if (id === "_channels") {
                 // eslint-disable-next-line @typescript-eslint/return-await -- Adding an await here causes test failures
@@ -1020,15 +1112,15 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                         mimeType: "fluid/object",
                         value: blob,
                     }
-                    : (0, runtime_utils_1.create404Response)(request);
+                    : (0, internal_6.create404Response)(request);
             }
             else if (requestParser.pathParts.length > 0) {
                 return await this.channelCollection.request(request);
             }
-            return (0, runtime_utils_1.create404Response)(request);
+            return (0, internal_6.create404Response)(request);
         }
         catch (error) {
-            return (0, runtime_utils_1.exceptionToResponse)(error);
+            return (0, internal_6.exceptionToResponse)(error);
         }
     }
     /**
@@ -1042,48 +1134,60 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     }
     /** 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.
+        const message = (0, index_js_3.extractSummaryMetadataMessage)(this.deltaManager.lastMessage) ??
+            this.messageAtLastSummary;
+        const documentSchema = this.documentsSchemaController.summarizeDocumentSchema(this.deltaManager.lastSequenceNumber);
+        // Is document schema explicit control on?
+        const explitiSchemaControl = documentSchema?.runtime.explicitSchemaControl;
         const metadata = {
             ...this.createContainerMetadata,
             // Increment the summary number for the next summary that will be generated.
             summaryNumber: this.nextSummaryNumber++,
             summaryFormatVersion: 1,
             ...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, index_js_1.extractSummaryMetadataMessage)(this.deltaManager.lastMessage) ??
-                this.messageAtLastSummary,
             telemetryDocumentId: this.telemetryDocumentId,
-            idCompressorMode: this.idCompressorMode,
+            // If explicit document schema control is not on, use legacy way to supply last message (using 'message' property).
+            // Otherwise use new 'lastMessage' property, but also put content into the 'message' property that cases old
+            // runtimes (that preceed document schema control capabilities) to close container on load due to mismatch in
+            // last message's sequence number.
+            // See also lastMessageFromMetadata()
+            message: explitiSchemaControl
+                ? { sequenceNumber: -1 }
+                : message,
+            lastMessage: explitiSchemaControl ? message : undefined,
+            documentSchema,
         };
-        (0, runtime_utils_1.addBlobToSummary)(summaryTree, index_js_1.metadataBlobName, JSON.stringify(metadata));
+        (0, internal_6.addBlobToSummary)(summaryTree, index_js_3.metadataBlobName, JSON.stringify(metadata));
     }
     addContainerStateToSummary(summaryTree, fullTree, trackState, telemetryContext) {
         this.addMetadataToSummary(summaryTree);
         if (this._idCompressor) {
             const idCompressorState = JSON.stringify(this._idCompressor.serialize(false));
-            (0, runtime_utils_1.addBlobToSummary)(summaryTree, index_js_1.idCompressorBlobName, idCompressorState);
+            (0, internal_6.addBlobToSummary)(summaryTree, index_js_3.idCompressorBlobName, idCompressorState);
         }
         if (this.remoteMessageProcessor.partialMessages.size > 0) {
             const content = JSON.stringify([...this.remoteMessageProcessor.partialMessages]);
-            (0, runtime_utils_1.addBlobToSummary)(summaryTree, index_js_1.chunksBlobName, content);
+            (0, internal_6.addBlobToSummary)(summaryTree, index_js_3.chunksBlobName, content);
         }
         const dataStoreAliases = this.channelCollection.aliases;
         if (dataStoreAliases.size > 0) {
-            (0, runtime_utils_1.addBlobToSummary)(summaryTree, index_js_1.aliasBlobName, JSON.stringify([...dataStoreAliases]));
+            (0, internal_6.addBlobToSummary)(summaryTree, index_js_3.aliasBlobName, JSON.stringify([...dataStoreAliases]));
         }
         if (this.summarizerClientElection) {
             const electedSummarizerContent = JSON.stringify(this.summarizerClientElection?.serialize());
-            (0, runtime_utils_1.addBlobToSummary)(summaryTree, index_js_1.electedSummarizerBlobName, electedSummarizerContent);
+            (0, internal_6.addBlobToSummary)(summaryTree, index_js_3.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.addSummarizeResultToSummary)(summaryTree, index_js_1.blobsTreeName, blobManagerSummary);
+            (0, internal_6.addSummarizeResultToSummary)(summaryTree, index_js_3.blobsTreeName, blobManagerSummary);
         }
         const gcSummary = this.garbageCollector.summarize(fullTree, trackState, telemetryContext);
         if (gcSummary !== undefined) {
-            (0, runtime_utils_1.addSummarizeResultToSummary)(summaryTree, runtime_definitions_1.gcTreeKey, gcSummary);
+            (0, internal_6.addSummarizeResultToSummary)(summaryTree, internal_5.gcTreeKey, gcSummary);
         }
     }
     // Track how many times the container tries to reconnect with pending messages.
@@ -1114,14 +1218,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_js_1.ContainerMessageType.ChunkedOp) {
-            this.consecutiveReconnects = 0;
-        }
+    resetReconnectCount() {
+        this.consecutiveReconnects = 0;
     }
     replayPendingStates() {
         // We need to be able to send ops to replay states
@@ -1134,7 +1232,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // Save the old state, reset to false, disable event emit
         const oldState = this.dirtyContainer;
         this.dirtyContainer = false;
-        (0, core_utils_1.assert)(this.emitDirtyDocumentEvent, 0x127 /* "dirty document event not set on replay" */);
+        (0, internal_2.assert)(this.emitDirtyDocumentEvent, 0x127 /* "dirty document event not set on replay" */);
         this.emitDirtyDocumentEvent = false;
         let newState;
         try {
@@ -1156,9 +1254,9 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      */
     // TODO: markfields: confirm Local- versus Outbound- ContainerRuntimeMessage typing
     parseLocalOpContent(serializedContents) {
-        (0, core_utils_1.assert)(serializedContents !== undefined, 0x6d5 /* content must be defined */);
+        (0, internal_2.assert)(serializedContents !== undefined, 0x6d5 /* content must be defined */);
         const message = JSON.parse(serializedContents);
-        (0, core_utils_1.assert)(message.type !== undefined, 0x6d6 /* incorrect op content format */);
+        (0, internal_2.assert)(message.type !== undefined, 0x6d6 /* incorrect op content format */);
         return message;
     }
     async applyStashedOp(serializedOpContent) {
@@ -1170,7 +1268,18 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             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 */);
+                // 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
+                // was loaded from a state serialized at the same time as the summary tree in the stashed state
+                // then it would generate IDs that collide with any in later stashed ops.
+                // In the future, IdCompressor could be extended to have an "applyStashedOp" or similar method
+                // 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.
+                (0, internal_2.assert)(this.idCompressorMode !== undefined, 0x8f1 /* ID compressor should be in use */);
+                return;
+            case messageTypes_js_1.ContainerMessageType.DocumentSchemaChange:
                 return;
             case messageTypes_js_1.ContainerMessageType.BlobAttach:
                 return;
@@ -1180,14 +1289,14 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 throw new Error("rejoin not expected here");
             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");
+                throw new internal_7.LoggingError("GC op not expected to be stashed in summarizer");
             default: {
                 // This should be extremely rare for stashed ops.
                 // It would require a newer runtime stashing ops and then an older one applying them,
                 // e.g. if an app rolled back its container version
                 const compatBehavior = opContents.compatDetails?.behavior;
                 if (!compatBehaviorAllowsMessageType(opContents.type, compatBehavior)) {
-                    const error = telemetry_utils_1.DataProcessingError.create("Stashed runtime message of unknown type", "applyStashedOp", undefined /* sequencedMessage */, {
+                    const error = internal_7.DataProcessingError.create("Stashed runtime message of unknown type", "applyStashedOp", undefined /* sequencedMessage */, {
                         messageDetails: JSON.stringify({
                             type: opContents.type,
                             compatBehavior,
@@ -1201,12 +1310,14 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             }
         }
     }
-    setConnectionState(connected, clientId) {
-        if (connected && this.idCompressorMode === "delayed" && !this.compressorLoadInitiated) {
-            this.compressorLoadInitiated = true;
-            this.createIdCompressor()
+    async loadIdCompressor() {
+        if (this._idCompressor === undefined &&
+            this.idCompressorMode !== undefined &&
+            this._loadIdCompressor === undefined) {
+            this._loadIdCompressor = this.createIdCompressor()
                 .then((compressor) => {
                 this._idCompressor = compressor;
+                // Finalize any ranges we received while the compressor was turned off.
                 for (const range of this.pendingIdCompressorOps) {
                     this._idCompressor.finalizeCreationRange(range);
                 }
@@ -1214,8 +1325,16 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             })
                 .catch((error) => {
                 this.logger.sendErrorEvent({ eventName: "IdCompressorDelayedLoad" }, error);
+                throw error;
             });
         }
+        return this._loadIdCompressor;
+    }
+    setConnectionState(connected, clientId) {
+        if (connected && this.idCompressorMode === "delayed") {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            this.loadIdCompressor();
+        }
         if (connected === false && this.delayConnectClientId !== undefined) {
             this.delayConnectClientId = undefined;
             this.mc.logger.sendTelemetryEvent({
@@ -1224,27 +1343,23 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             // Don't propagate "disconnected" event because we didn't propagate the previous "connected" event
             return;
         }
+        if (!connected) {
+            this.documentsSchemaController.onDisconnect();
+        }
         // If there are stashed blobs in the pending state, we need to delay
         // propagation of the "connected" event until we have uploaded them to
         // ensure we don't submit ops referencing a blob that has not been uploaded
         const connecting = connected && !this._connected;
-        if (connecting && this.blobManager.hasPendingStashedBlobs()) {
-            (0, core_utils_1.assert)(!this.delayConnectClientId, 0x791 /* Connect event delay must be canceled before subsequent connect event */);
-            (0, core_utils_1.assert)(!!clientId, 0x792 /* Must have clientId when connecting */);
+        if (connecting && this.blobManager.hasPendingStashedUploads()) {
+            (0, internal_2.assert)(!this.delayConnectClientId, 0x791 /* Connect event delay must be canceled before subsequent connect event */);
+            (0, internal_2.assert)(!!clientId, 0x792 /* Must have clientId when connecting */);
             this.delayConnectClientId = clientId;
-            this.blobManager.processStashedChanges().then(() => {
-                // make sure we didn't reconnect before the promise resolved
-                if (this.delayConnectClientId === clientId && !this.disposed) {
-                    this.delayConnectClientId = undefined;
-                    this.setConnectionStateCore(connected, clientId);
-                }
-            }, (error) => this.closeFn(error));
             return;
         }
         this.setConnectionStateCore(connected, clientId);
     }
     setConnectionStateCore(connected, clientId) {
-        (0, core_utils_1.assert)(!this.delayConnectClientId, 0x394 /* connect event delay must be cleared before propagating connect event */);
+        (0, internal_2.assert)(!this.delayConnectClientId, 0x394 /* connect event delay must be cleared before propagating connect event */);
         this.verifyNotClosed();
         // There might be no change of state due to Container calling this API after loading runtime.
         const changeOfState = this._connected !== connected;
@@ -1262,13 +1377,13 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             this._perfSignalData.trackingSignalSequenceNumber = undefined;
         }
         else {
-            (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x3cd /* Connection is possible only if container exists in storage */);
+            (0, internal_2.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x3cd /* Connection is possible only if container exists in storage */);
         }
         // Fail while disconnected
         if (reconnection) {
             this.consecutiveReconnects++;
             if (!this.shouldContinueReconnecting()) {
-                this.closeFn(telemetry_utils_1.DataProcessingError.create("Runtime detected too many reconnects with no progress syncing local ops.", "setConnectionState", undefined, {
+                this.closeFn(internal_7.DataProcessingError.create("Runtime detected too many reconnects with no progress syncing local ops.", "setConnectionState", undefined, {
                     dataLoss: 1,
                     attempts: this.consecutiveReconnects,
                     pendingMessages: this.pendingMessagesCount,
@@ -1281,7 +1396,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         }
         this.channelCollection.setConnectionState(connected, clientId);
         this.garbageCollector.setConnectionState(connected, clientId);
-        (0, telemetry_utils_1.raiseConnectedEvent)(this.mc.logger, this, connected, clientId);
+        (0, internal_7.raiseConnectedEvent)(this.mc.logger, this, connected, clientId);
     }
     async notifyOpReplay(message) {
         await this.pendingStateManager.applyStashedOpsAt(message.sequenceNumber);
@@ -1326,10 +1441,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, internal_2.assert)(message.type !== messageTypes_js_1.ContainerMessageType.ChunkedOp, 0x93b /* we should never get here with chunked ops */);
             let localOpMetadata;
-            if (local &&
-                messageWithContext.modernRuntimeMessage &&
-                message.type !== messageTypes_js_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,
@@ -1344,7 +1462,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) {
@@ -1378,7 +1496,10 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                     messageWithContext.message.metadata?.savedOp ===
                         true)) {
                     const range = messageWithContext.message.contents;
+                    // 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) {
+                        (0, internal_2.assert)(this.idCompressorMode !== undefined, 0x93c /* id compressor should be enabled */);
                         this.pendingIdCompressorOps.push(range);
                     }
                     else {
@@ -1390,8 +1511,14 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 this.garbageCollector.processMessage(messageWithContext.message, local);
                 break;
             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, internal_2.assert)(false, 0x93d /* should not even get here */);
             case messageTypes_js_1.ContainerMessageType.Rejoin:
                 break;
+            case messageTypes_js_1.ContainerMessageType.DocumentSchemaChange:
+                this.documentsSchemaController.processDocumentSchemaOp(messageWithContext.message.contents, messageWithContext.local, messageWithContext.message.sequenceNumber);
+                break;
             default: {
                 // If we didn't necessarily expect a runtime message type, then no worries - just return
                 // e.g. this case applies to system ops, or legacy ops that would have fallen into the above cases anyway.
@@ -1401,7 +1528,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 const compatBehavior = messageWithContext.message.compatDetails?.behavior;
                 if (!compatBehaviorAllowsMessageType(messageWithContext.message.type, compatBehavior)) {
                     const { message } = messageWithContext;
-                    const error = telemetry_utils_1.DataProcessingError.create(
+                    const error = internal_7.DataProcessingError.create(
                     // Former assert 0x3ce
                     "Runtime message of unknown type", "OpProcessing", message, {
                         local,
@@ -1485,9 +1612,9 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      * This method is expected to be called at the end of a batch.
      */
     flush() {
-        (0, core_utils_1.assert)(this._orderSequentiallyCalls === 0, 0x24c /* "Cannot call `flush()` from `orderSequentially`'s callback" */);
+        (0, internal_2.assert)(this._orderSequentiallyCalls === 0, 0x24c /* "Cannot call `flush()` from `orderSequentially`'s callback" */);
         this.outbox.flush();
-        (0, core_utils_1.assert)(this.outbox.isEmpty, 0x3cf /* reentrancy */);
+        (0, internal_2.assert)(this.outbox.isEmpty, 0x3cf /* reentrancy */);
     }
     /**
      * {@inheritDoc @fluidframework/runtime-definitions#IContainerRuntimeBase.orderSequentially}
@@ -1512,15 +1639,15 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                     checkpoint.rollback((message) => this.rollback(message.contents, message.localOpMetadata));
                 }
                 catch (err) {
-                    const error2 = (0, telemetry_utils_1.wrapError)(err, (message) => {
-                        return telemetry_utils_1.DataProcessingError.create(`RollbackError: ${message}`, "checkpointRollback", undefined);
+                    const error2 = (0, internal_7.wrapError)(err, (message) => {
+                        return internal_7.DataProcessingError.create(`RollbackError: ${message}`, "checkpointRollback", undefined);
                     });
                     this.closeFn(error2);
                     throw error2;
                 }
             }
             else {
-                this.closeFn((0, telemetry_utils_1.wrapError)(error, (errorMessage) => new telemetry_utils_1.GenericError(`orderSequentially callback exception: ${errorMessage}`, error, {
+                this.closeFn((0, internal_7.wrapError)(error, (errorMessage) => new internal_7.GenericError(`orderSequentially callback exception: ${errorMessage}`, error, {
                     orderSequentiallyCalls: this._orderSequentiallyCalls,
                 })));
             }
@@ -1530,7 +1657,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             this._orderSequentiallyCalls--;
         }
         // We don't flush on TurnBased since we expect all messages in the same JS turn to be part of the same batch
-        if (this.flushMode !== runtime_definitions_1.FlushMode.TurnBased && this._orderSequentiallyCalls === 0) {
+        if (this.flushMode !== internal_5.FlushMode.TurnBased && this._orderSequentiallyCalls === 0) {
             this.flush();
         }
         return result;
@@ -1559,16 +1686,16 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         }
         const channel = await context.realize();
         if (channel.entryPoint === undefined) {
-            throw new telemetry_utils_1.UsageError("entryPoint must be defined on data store runtime for using getAliasedDataStoreEntryPoint");
+            throw new internal_7.UsageError("entryPoint must be defined on data store runtime for using getAliasedDataStoreEntryPoint");
         }
         this.garbageCollector.nodeUpdated(`/${internalId}`, "Loaded", undefined /* timestampMs */, context.packagePath);
         return channel.entryPoint;
     }
     createDetachedDataStore(pkg, loadingGroupId) {
-        return this.channelCollection.createDetachedDataStoreCore(pkg, loadingGroupId);
+        return this.channelCollection.createDetachedDataStore(pkg, loadingGroupId);
     }
     async createDataStore(pkg, loadingGroupId) {
-        const context = this.channelCollection._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], undefined, // props
+        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);
     }
@@ -1576,7 +1703,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      * @deprecated 0.16 Issue #1537, #3631
      */
     async _createDataStoreWithProps(pkg, props) {
-        const context = this.channelCollection._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [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() {
@@ -1588,7 +1715,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      * Are we in the middle of batching ops together?
      */
     currentlyBatching() {
-        return this.flushMode !== runtime_definitions_1.FlushMode.Immediate || this._orderSequentiallyCalls !== 0;
+        return this.flushMode !== internal_5.FlushMode.Immediate || this._orderSequentiallyCalls !== 0;
     }
     getQuorum() {
         return this._quorum;
@@ -1621,6 +1748,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 }
                 break;
             }
+            case messageTypes_js_1.ContainerMessageType.IdAllocation:
+            case messageTypes_js_1.ContainerMessageType.DocumentSchemaChange:
             case messageTypes_js_1.ContainerMessageType.GC: {
                 return false;
             }
@@ -1647,7 +1776,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     /**
      * Submits the signal to be sent to other clients.
      * @param type - Type of the signal.
-     * @param content - Content of the signal.
+     * @param content - Content of the signal. Should be a JSON serializable object or primitive.
      * @param targetClientId - When specified, the signal is only sent to the provided client id.
      */
     submitSignal(type, content, targetClientId) {
@@ -1657,10 +1786,10 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     }
     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" */);
+            (0, internal_2.assert)(this.attachState === container_definitions_1.AttachState.Attaching, 0x12d /* "Container Context should already be in attaching state" */);
         }
         else {
-            (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x12e /* "Container Context should already be in attached state" */);
+            (0, internal_2.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x12e /* "Container Context should already be in attached state" */);
             this.emit("attached");
         }
         if (attachState === container_definitions_1.AttachState.Attached && !this.hasPendingMessages()) {
@@ -1683,19 +1812,22 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // We can finalize any allocated IDs since we're the only client
         const idRange = this._idCompressor?.takeNextCreationRange();
         if (idRange !== undefined) {
+            (0, internal_2.assert)(idRange.ids === undefined || idRange.ids.firstGenCount === 1, 0x93e /* No other ranges should be taken while container is detached. */);
             this._idCompressor?.finalizeCreationRange(idRange);
         }
         const summarizeResult = this.channelCollection.getAttachSummary(telemetryContext);
         // Wrap data store summaries in .channels subtree.
-        (0, index_js_1.wrapSummaryInChannelsTree)(summarizeResult);
+        (0, index_js_3.wrapSummaryInChannelsTree)(summarizeResult);
         this.addContainerStateToSummary(summarizeResult, true /* fullTree */, false /* trackState */, telemetryContext);
         return summarizeResult.summary;
     }
     async summarizeInternal(fullTree, trackState, telemetryContext) {
         const summarizeResult = await this.channelCollection.summarize(fullTree, trackState, telemetryContext);
         // Wrap data store summaries in .channels subtree.
-        (0, index_js_1.wrapSummaryInChannelsTree)(summarizeResult);
-        const pathPartsForChildren = [runtime_definitions_1.channelsTreeName];
+        (0, index_js_3.wrapSummaryInChannelsTree)(summarizeResult);
+        const pathPartsForChildren = [internal_5.channelsTreeName];
+        // Ensure that ID compressor had a chance to load, if we are using delayed mode.
+        await this.loadIdCompressor();
         this.addContainerStateToSummary(summarizeResult, fullTree, trackState, telemetryContext);
         return {
             ...summarizeResult,
@@ -1709,7 +1841,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     async summarize(options) {
         this.verifyNotClosed();
         const { fullTree = false, trackState = true, summaryLogger = this.mc.logger, runGC = this.garbageCollector.shouldRunGC, runSweep, fullGC, } = options;
-        const telemetryContext = new runtime_utils_1.TelemetryContext();
+        const telemetryContext = new internal_6.TelemetryContext();
         // Add the options that are used to generate this summary to the telemetry context.
         telemetryContext.setMultiple("fluid_Summarize", "Options", {
             fullTree,
@@ -1723,7 +1855,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 await this.collectGarbage({ logger: summaryLogger, runSweep, fullGC }, telemetryContext);
             }
             const { stats, summary } = await this.summarizerNode.summarize(fullTree, trackState, telemetryContext);
-            (0, core_utils_1.assert)(summary.type === protocol_definitions_1.SummaryType.Tree, 0x12f /* "Container Runtime's summarize should always return a tree" */);
+            (0, internal_2.assert)(summary.type === protocol_definitions_1.SummaryType.Tree, 0x12f /* "Container Runtime's summarize should always return a tree" */);
             return { stats, summary };
         }
         finally {
@@ -1751,7 +1883,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      * @see IGarbageCollectionRuntime.getGCData
      */
     async getGCData(fullGC) {
-        const builder = new runtime_utils_1.GCDataBuilder();
+        const builder = new internal_6.GCDataBuilder();
         const dsGCData = await this.summarizerNode.getGCData(fullGC);
         builder.addNodes(dsGCData.gcNodes);
         const blobsGCData = this.blobManager.getGCData(fullGC);
@@ -1771,21 +1903,6 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         const { dataStoreRoutes } = this.getDataStoreAndBlobManagerRoutes(usedRoutes);
         this.channelCollection.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.channelCollection.updateUnusedRoutes(dataStoreRoutes);
-    }
-    /**
-     * @deprecated Replaced by deleteSweepReadyNodes.
-     */
-    deleteUnusedNodes(unusedRoutes) {
-        throw new Error("deleteUnusedRoutes should not be called");
-    }
     /**
      * After GC has run and identified nodes that are sweep ready, this is called to delete the sweep ready nodes.
      * @param sweepReadyRoutes - The routes of nodes that are sweep ready and should be deleted.
@@ -1823,9 +1940,9 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      */
     getNodeType(nodePath) {
         if (this.isBlobPath(nodePath)) {
-            return index_js_2.GCNodeType.Blob;
+            return index_js_1.GCNodeType.Blob;
         }
-        return this.channelCollection.getGCNodeType(nodePath) ?? index_js_2.GCNodeType.Other;
+        return this.channelCollection.getGCNodeType(nodePath) ?? index_js_1.GCNodeType.Other;
     }
     /**
      * Called by GC to retrieve the package path of the node with the given path. The node should belong to a
@@ -1838,13 +1955,13 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             return ["_gcRoot"];
         }
         switch (this.getNodeType(nodePath)) {
-            case index_js_2.GCNodeType.Blob:
+            case index_js_1.GCNodeType.Blob:
                 return [blobManager_js_1.BlobManager.basePath];
-            case index_js_2.GCNodeType.DataStore:
-            case index_js_2.GCNodeType.SubDataStore:
+            case index_js_1.GCNodeType.DataStore:
+            case index_js_1.GCNodeType.SubDataStore:
                 return this.channelCollection.getDataStorePackagePath(nodePath);
             default:
-                (0, core_utils_1.assert)(false, 0x2de /* "Package path requested for unsupported node type." */);
+                (0, internal_2.assert)(false, 0x2de /* "Package path requested for unsupported node type." */);
         }
     }
     /**
@@ -1905,16 +2022,16 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // 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;
-        const summaryNumberLogger = (0, telemetry_utils_1.createChildLogger)({
+        const summaryNumberLogger = (0, internal_7.createChildLogger)({
             logger: summaryLogger,
             properties: {
                 all: { summaryNumber },
             },
         });
-        (0, core_utils_1.assert)(this.outbox.isEmpty, 0x3d1 /* Can't trigger summary in the middle of a batch */);
+        (0, internal_2.assert)(this.outbox.isEmpty, 0x3d1 /* Can't trigger summary in the middle of a batch */);
         // We close the summarizer and download a new snapshot and reload the container
         if (refreshLatestAck === true) {
-            return this.prefetchLatestSummaryThenClose((0, telemetry_utils_1.createChildLogger)({
+            return this.prefetchLatestSummaryThenClose((0, internal_7.createChildLogger)({
                 logger: summaryNumberLogger,
                 properties: { all: { safeSummary: true } },
             }));
@@ -1998,7 +2115,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 // That said, we rely on submitSystemMessage() that today only works in connected state.
                 // So if we fail here, it either means that RunWhileConnectedCoordinator does not work correctly,
                 // OR that design changed and we need to remove this check and fix submitSystemMessage.
-                (0, core_utils_1.assert)(this.connected, 0x258 /* "connected" */);
+                (0, internal_2.assert)(this.connected, 0x258 /* "connected" */);
                 // Ensure that lastSequenceNumber has not changed after pausing.
                 // We need the summary op's reference sequence number to match our summary sequence number,
                 // otherwise we'll get the wrong sequence number stamped on the summary's .protocol attributes.
@@ -2008,7 +2125,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                         error: `lastSequenceNumber changed before uploading to storage. ${this.deltaManager.lastSequenceNumber} !== ${summaryRefSeqNum}`,
                     };
                 }
-                (0, core_utils_1.assert)(summaryRefSeqNum === this.deltaManager.lastMessage?.sequenceNumber, 0x395 /* it's one and the same thing */);
+                (0, internal_2.assert)(summaryRefSeqNum === this.deltaManager.lastMessage?.sequenceNumber, 0x395 /* it's one and the same thing */);
                 if (lastAck !== this.summaryCollection.latestAck) {
                     return {
                         continue: false,
@@ -2053,7 +2170,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 const validateResult = this.summarizerNode.validateSummary();
                 if (!validateResult.success) {
                     const { success, ...loggingProps } = validateResult;
-                    const error = new index_js_1.RetriableSummaryError(validateResult.reason, validateResult.retryAfterSeconds, { ...loggingProps });
+                    const error = new index_js_3.RetriableSummaryError(validateResult.reason, validateResult.retryAfterSeconds, { ...loggingProps });
                     return {
                         stage: "base",
                         referenceSequenceNumber: summaryRefSeqNum,
@@ -2072,11 +2189,11 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             // Counting dataStores and handles
             // Because handles are unchanged dataStores in the current logic,
             // summarized dataStore count is total dataStore count minus handle count
-            const dataStoreTree = summaryTree.tree[runtime_definitions_1.channelsTreeName];
-            (0, core_utils_1.assert)(dataStoreTree.type === protocol_definitions_1.SummaryType.Tree, 0x1fc /* "summary is not a tree" */);
+            const dataStoreTree = summaryTree.tree[internal_5.channelsTreeName];
+            (0, internal_2.assert)(dataStoreTree.type === protocol_definitions_1.SummaryType.Tree, 0x1fc /* "summary is not a tree" */);
             const handleCount = Object.values(dataStoreTree.tree).filter((value) => value.type === protocol_definitions_1.SummaryType.Handle).length;
-            const gcSummaryTreeStats = summaryTree.tree[runtime_definitions_1.gcTreeKey]
-                ? (0, runtime_utils_1.calculateStats)(summaryTree.tree[runtime_definitions_1.gcTreeKey])
+            const gcSummaryTreeStats = summaryTree.tree[internal_5.gcTreeKey]
+                ? (0, internal_6.calculateStats)(summaryTree.tree[internal_5.gcTreeKey])
                 : undefined;
             const summaryStats = {
                 dataStoreCount: this.channelCollection.size,
@@ -2187,7 +2304,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // the summarizer.
         if (finalAttempt &&
             this.mc.config.getBoolean("Fluid.Summarizer.SkipFailingIncorrectSummary")) {
-            const error = telemetry_utils_1.DataProcessingError.create("Pending ops during summarization", "submitSummary", undefined, { pendingMessages: this.pendingMessagesCount });
+            const error = internal_7.DataProcessingError.create("Pending ops during summarization", "submitSummary", undefined, { pendingMessages: this.pendingMessagesCount });
             logger.sendErrorEvent({
                 eventName: "SkipFailingIncorrectSummary",
                 referenceSequenceNumber,
@@ -2200,7 +2317,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 index_js_1.RetriableSummaryError("PendingOpsWhileSummarizing", retryDelayMs / 1000, {
+            const error = new index_js_3.RetriableSummaryError("PendingOpsWhileSummarizing", retryDelayMs / 1000, {
                 count: this.pendingMessagesCount,
                 beforeGenerate: beforeSummaryGeneration,
             });
@@ -2220,11 +2337,11 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     }
     updateDocumentDirtyState(dirty) {
         if (this.attachState !== container_definitions_1.AttachState.Attached) {
-            (0, core_utils_1.assert)(dirty, 0x3d2 /* Non-attached container is dirty */);
+            (0, internal_2.assert)(dirty, 0x3d2 /* Non-attached container is dirty */);
         }
         else {
             // Other way is not true = see this.isContainerMessageDirtyable()
-            (0, core_utils_1.assert)(!dirty || this.hasPendingMessages(), 0x3d3 /* if doc is dirty, there has to be pending ops */);
+            (0, internal_2.assert)(!dirty || this.hasPendingMessages(), 0x3d3 /* if doc is dirty, there has to be pending ops */);
         }
         if (this.dirtyContainer === dirty) {
             return;
@@ -2253,19 +2370,18 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 const idAllocationBatchMessage = {
                     contents: JSON.stringify(idAllocationMessage),
                     referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
-                    metadata: undefined,
-                    localOpMetadata: undefined,
-                    type: messageTypes_js_1.ContainerMessageType.IdAllocation,
                 };
                 this.outbox.submitIdAllocation(idAllocationBatchMessage);
             }
         }
     }
-    submit(containerRuntimeMessage, localOpMetadata = undefined, metadata = undefined) {
+    submit(containerRuntimeMessage, localOpMetadata = undefined, metadata) {
         this.verifyNotClosed();
         this.verifyCanSubmitOps();
         // There should be no ops in detached container state!
-        (0, core_utils_1.assert)(this.attachState !== container_definitions_1.AttachState.Detached, 0x132 /* "sending ops in detached container" */);
+        (0, internal_2.assert)(this.attachState !== container_definitions_1.AttachState.Detached, 0x132 /* "sending ops in detached container" */);
+        (0, internal_2.assert)(metadata === undefined ||
+            containerRuntimeMessage.type === messageTypes_js_1.ContainerMessageType.BlobAttach, 0x93f /* metadata */);
         const serializedContent = JSON.stringify(containerRuntimeMessage);
         // Note that the real (non-proxy) delta manager is used here to get the readonly info. This is because
         // container runtime's ability to submit ops depend on the actual readonly state of the delta manager.
@@ -2278,7 +2394,6 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         const type = containerRuntimeMessage.type;
         const message = {
             contents: serializedContent,
-            type,
             metadata,
             localOpMetadata,
             referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
@@ -2293,6 +2408,20 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             }
             else {
                 this.submitIdAllocationOpIfNeeded();
+                // Allow document schema controller to send a message if it needs to propose change in document schema.
+                // If it needs to send a message, it will call provided callback with payload of such message and rely
+                // on this callback to do actual sending.
+                const contents = this.documentsSchemaController.maybeSendSchemaMessage();
+                if (contents) {
+                    const msg = {
+                        type: messageTypes_js_1.ContainerMessageType.DocumentSchemaChange,
+                        contents,
+                    };
+                    this.outbox.submit({
+                        contents: JSON.stringify(msg),
+                        referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
+                    });
+                }
                 // 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.
@@ -2356,29 +2485,29 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             }
         };
         switch (this.flushMode) {
-            case runtime_definitions_1.FlushMode.TurnBased:
+            case internal_5.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 runtime_definitions_1.FlushModeExperimental.Async:
+            case internal_5.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:
-                (0, core_utils_1.assert)(this._orderSequentiallyCalls > 0, 0x587 /* Unreachable unless running under orderSequentially */);
+                (0, internal_2.assert)(this._orderSequentiallyCalls > 0, 0x587 /* Unreachable unless running under orderSequentially */);
                 break;
         }
     }
     submitSummaryMessage(contents, referenceSequenceNumber) {
         this.verifyNotClosed();
-        (0, core_utils_1.assert)(this.connected, 0x133 /* "Container disconnected when trying to submit system message" */);
+        (0, internal_2.assert)(this.connected, 0x133 /* "Container disconnected when trying to submit system message" */);
         // System message should not be sent in the middle of the batch.
-        (0, core_utils_1.assert)(this.outbox.isEmpty, 0x3d4 /* System op in the middle of a batch */);
+        (0, internal_2.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)
@@ -2399,7 +2528,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, index_js_3.getLongStack)(() => new telemetry_utils_1.UsageError(errorMessage)));
+                (0, index_js_2.getLongStack)(() => new internal_7.UsageError(errorMessage)));
                 this.opReentryCallsToReport--;
             }
             // Creating ops while processing ops can lead
@@ -2415,7 +2544,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             // The runtime must enforce op coherence by not allowing ops to be submitted
             // while ops are being processed.
             if (this.enableOpReentryCheck) {
-                throw new telemetry_utils_1.UsageError(errorMessage);
+                throw new internal_7.UsageError(errorMessage);
             }
         }
     }
@@ -2440,7 +2569,7 @@ 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, 0x8f2 /* Summarizer never reconnects so should never resubmit */);
+        (0, internal_2.assert)(!this.isSummarizerClient, 0x8f2 /* Summarizer never reconnects so should never resubmit */);
         switch (message.type) {
             case messageTypes_js_1.ContainerMessageType.FluidDataStoreOp:
             case messageTypes_js_1.ContainerMessageType.Attach:
@@ -2464,6 +2593,11 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             case messageTypes_js_1.ContainerMessageType.GC:
                 this.submit(message);
                 break;
+            case messageTypes_js_1.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: {
                 // This case should be very rare - it would imply an op was stashed from a
                 // future version of runtime code and now is being applied on an older version.
@@ -2476,7 +2610,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                     });
                 }
                 else {
-                    const error = telemetry_utils_1.DataProcessingError.create("Resubmitting runtime message of unknown type", "reSubmitCore", undefined /* sequencedMessage */, {
+                    const error = internal_7.DataProcessingError.create("Resubmitting runtime message of unknown type", "reSubmitCore", undefined /* sequencedMessage */, {
                         messageDetails: JSON.stringify({
                             type: message.type,
                             compatBehavior,
@@ -2506,8 +2640,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     async refreshLatestSummaryAck(options) {
         const { proposalHandle, ackHandle, summaryRefSeq, summaryLogger } = options;
         // proposalHandle is always passed from RunningSummarizer.
-        (0, core_utils_1.assert)(proposalHandle !== undefined, 0x766 /* proposalHandle should be available */);
-        const readAndParseBlob = async (id) => (0, driver_utils_1.readAndParse)(this.storage, id);
+        (0, internal_2.assert)(proposalHandle !== undefined, 0x766 /* proposalHandle should be available */);
+        const readAndParseBlob = async (id) => (0, internal_4.readAndParse)(this.storage, id);
         const result = await this.summarizerNode.refreshLatestSummary(proposalHandle, summaryRefSeq);
         /**
          * When refreshing a summary ack, this check indicates a new ack of a summary that is newer than the
@@ -2534,7 +2668,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      * @returns a generic summarization error
      */
     async prefetchLatestSummaryThenClose(summaryLogger) {
-        const readAndParseBlob = async (id) => (0, driver_utils_1.readAndParse)(this.storage, id);
+        const readAndParseBlob = async (id) => (0, internal_4.readAndParse)(this.storage, id);
         // This is a performance optimization as the same parent is likely to be elected again, and would use its
         // cache to fetch the snapshot instead of the network.
         await this.fetchLatestSnapshotFromStorage(summaryLogger, {
@@ -2550,7 +2684,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     }
     async closeStaleSummarizer() {
         // Delay before restarting summarizer to prevent the summarizer from restarting too frequently.
-        await (0, core_utils_1.delay)(this.closeSummarizerDelayMs);
+        await (0, internal_2.delay)(this.closeSummarizerDelayMs);
         this._summarizer?.stop("latestSummaryStateStale");
         this.disposeFn();
     }
@@ -2560,16 +2694,16 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      * overridden via options.
      */
     async fetchLatestSnapshotFromStorage(logger, event, readAndParseBlob) {
-        return telemetry_utils_1.PerformanceEvent.timedExecAsync(logger, event, async (perfEvent) => {
+        return internal_7.PerformanceEvent.timedExecAsync(logger, event, async (perfEvent) => {
             const stats = {};
             const trace = client_utils_1.Trace.start();
-            const versions = await this.storage.getVersions(null, 1, "prefetchLatestSummaryBeforeClose", driver_definitions_1.FetchSource.noCache);
-            (0, core_utils_1.assert)(!!versions && !!versions[0], 0x137 /* "Failed to get version from storage" */);
+            const versions = await this.storage.getVersions(null, 1, "prefetchLatestSummaryBeforeClose", internal_3.FetchSource.noCache);
+            (0, internal_2.assert)(!!versions && !!versions[0], 0x137 /* "Failed to get version from storage" */);
             stats.getVersionDuration = trace.trace().duration;
             const maybeSnapshot = await this.storage.getSnapshotTree(versions[0]);
-            (0, core_utils_1.assert)(!!maybeSnapshot, 0x138 /* "Failed to get snapshot from storage" */);
+            (0, internal_2.assert)(!!maybeSnapshot, 0x138 /* "Failed to get snapshot from storage" */);
             stats.getSnapshotDuration = trace.trace().duration;
-            const latestSnapshotRefSeq = await (0, runtime_utils_1.seqFromTree)(maybeSnapshot, readAndParseBlob);
+            const latestSnapshotRefSeq = await (0, internal_6.seqFromTree)(maybeSnapshot, readAndParseBlob);
             stats.snapshotRefSeq = latestSnapshotRefSeq;
             stats.snapshotVersion = versions[0].id;
             perfEvent.end(stats);
@@ -2583,7 +2717,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     getPendingLocalState(props) {
         this.verifyNotClosed();
         if (this._orderSequentiallyCalls !== 0) {
-            throw new telemetry_utils_1.UsageError("can't get state during orderSequentially");
+            throw new internal_7.UsageError("can't get state during orderSequentially");
         }
         this.imminentClosure || (this.imminentClosure = props?.notifyImminentClosure ?? false);
         const getSyncState = (pendingAttachmentBlobs) => {
@@ -2615,8 +2749,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // 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()));
+            ? internal_7.PerformanceEvent.timedExecAsync(this.mc.logger, perfEvent, async (event) => logAndReturnPendingState(event, getSyncState(await this.blobManager.attachAndGetPendingBlobs(props?.stopBlobAttachingSignal))))
+            : internal_7.PerformanceEvent.timedExec(this.mc.logger, perfEvent, (event) => logAndReturnPendingState(event, getSyncState()));
     }
     summarizeOnDemand(options) {
         if (this.isSummarizerClient) {
@@ -2629,7 +2763,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             // 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 telemetry_utils_1.UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
+            throw new internal_7.UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
         }
     }
     enqueueSummarize(options) {
@@ -2643,7 +2777,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             // 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 telemetry_utils_1.UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
+            throw new internal_7.UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
         }
     }
     /**
@@ -2658,16 +2792,15 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // eslint-disable-next-line no-restricted-syntax
         for (const prop in configuration) {
             if (typeof configuration[prop] === "number" && configuration[prop] < 0) {
-                throw new telemetry_utils_1.UsageError(`Summary heuristic configuration property "${prop}" cannot be less than 0`);
+                throw new internal_7.UsageError(`Summary heuristic configuration property "${prop}" cannot be less than 0`);
             }
         }
         if (configuration.minIdleTime > configuration.maxIdleTime) {
-            throw new telemetry_utils_1.UsageError(`"minIdleTime" [${configuration.minIdleTime}] cannot be greater than "maxIdleTime" [${configuration.maxIdleTime}]`);
+            throw new internal_7.UsageError(`"minIdleTime" [${configuration.minIdleTime}] cannot be greater than "maxIdleTime" [${configuration.maxIdleTime}]`);
         }
     }
     get groupedBatchingEnabled() {
-        const killSwitch = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableGroupedBatching");
-        return killSwitch !== true && this.runtimeOptions.enableGroupedBatching;
+        return this.documentSchema.opGroupingEnabled === true;
     }
 }
 exports.ContainerRuntime = ContainerRuntime;