@fluidframework/container-runtime 2.0.0-dev-rc.2.0.0.245554 → 2.0.0-dev-rc.3.0.0.250606

package/dist/containerRuntime.js

@@ -1,32 +1,36 @@
 "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;
+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 container_definitions_1 = require("@fluidframework/container-definitions");
 const core_utils_1 = require("@fluidframework/core-utils");
-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 protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const runtime_definitions_1 = require("@fluidframework/runtime-definitions");
 const runtime_utils_1 = require("@fluidframework/runtime-utils");
+const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 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,6 +85,11 @@ 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;
 // The actual limit is 1Mb (socket.io and Kafka limits)
@@ -104,26 +113,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;
 /**
@@ -172,7 +167,7 @@ async function createSummarizer(loader, url) {
             [container_definitions_1.LoaderHeader.cache]: false,
             [container_definitions_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,
@@ -200,6 +195,17 @@ async function createSummarizer(loader, url) {
     }
     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.
@@ -237,7 +243,7 @@ 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 { 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];
@@ -249,27 +255,34 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             }
         };
         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);
         });
+        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(
                 // pre-0.58 error message: SummaryMetadataMismatch
@@ -283,7 +296,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             }
         }
         // 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,20 +305,20 @@ 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 to disregard "off" setting (when it's safe so) and start
+            // using compressor in future sessions.
             // Everyting is possible, but it needs to be designed and executed carefully, when such need arises.
-            idCompressorMode = metadata?.idCompressorMode ?? "off";
+            idCompressorMode = metadata?.documentSchema?.runtime
+                ?.idCompressorMode;
         }
         else {
-            // FG overwrite
-            const enabled = mc.config.getBoolean("Fluid.ContainerRuntime.IdCompressorEnabled");
-            switch (enabled) {
+            switch (mc.config.getBoolean("Fluid.ContainerRuntime.IdCompressorEnabled")) {
                 case true:
                     idCompressorMode = "on";
                     break;
                 case false:
-                    idCompressorMode = "off";
+                    idCompressorMode = undefined;
                     break;
                 default:
                     idCompressorMode = enableRuntimeIdCompressor;
@@ -338,6 +351,24 @@ 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,
+        }, (schema) => {
+            runtime.onSchemaChange(schema);
+        });
+        const featureGatesForTelemetry = {
+            disableGroupedBatching,
+            disableCompression,
+        };
         const runtime = new containerRuntimeCtor(context, registry, metadata, electedSummarizerData, chunks ?? [], aliases ?? [], {
             summaryOptions,
             gcOptions,
@@ -346,10 +377,12 @@ 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);
         // 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 +411,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.
      */
@@ -458,7 +497,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 +511,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;
@@ -513,6 +547,20 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             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, telemetry_utils_1.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 +573,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 +594,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 +614,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 +622,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);
@@ -627,7 +671,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 throw new telemetry_utils_1.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,
@@ -643,7 +687,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             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, telemetry_utils_1.createChildLogger)({ logger: this.logger, namespace: "SummarizerNode" }), 
         // Summarize function to call when summarize is called. Summarizer node always tracks summary state.
         async (fullTree, trackState, telemetryContext) => this.summarizeInternal(fullTree, trackState, telemetryContext), 
         // Latest change sequence number, no changes since summary applied yet
@@ -687,26 +731,22 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             clientId: () => this.clientId,
             close: this.closeFn,
             connected: () => this.connected,
-            reSubmit: this.reSubmit.bind(this),
+            reSubmit: (message) => {
+                this.reSubmit(message);
+                this.flush();
+            },
             reSubmitBatch: this.reSubmitBatch.bind(this),
             isActiveConnection: () => this.innerDeltaManager.active,
             isAttached: () => this.attachState !== 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 +773,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);
@@ -745,16 +785,16 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 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 +816,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 +843,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,
@@ -829,6 +869,20 @@ 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);
     }
@@ -840,7 +894,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         (0, core_utils_1.assert)(false, 0x8eb /* should not be called */);
     }
     setChannelDirty(address) {
-        (0, core_utils_1.assert)(false, "should not be called");
+        (0, core_utils_1.assert)(false, 0x909 /* should not be called */);
     }
     /**
      * Initializes the state from the base snapshot this container runtime loaded from.
@@ -905,7 +959,7 @@ 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 */);
         const snapshotSeqNumber = snapshot.sequenceNumber;
@@ -1046,44 +1100,56 @@ 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, runtime_utils_1.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, runtime_utils_1.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, runtime_utils_1.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, runtime_utils_1.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, runtime_utils_1.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, runtime_utils_1.addSummarizeResultToSummary)(summaryTree, index_js_3.blobsTreeName, blobManagerSummary);
         }
         const gcSummary = this.garbageCollector.summarize(fullTree, trackState, telemetryContext);
         if (gcSummary !== undefined) {
@@ -1118,14 +1184,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
@@ -1174,7 +1234,9 @@ 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 */);
+                (0, core_utils_1.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;
@@ -1205,10 +1267,11 @@ 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;
                 for (const range of this.pendingIdCompressorOps) {
@@ -1218,8 +1281,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({
@@ -1228,6 +1299,9 @@ 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
@@ -1330,10 +1404,13 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         this.scheduleManager.beforeOpProcessing(message);
         this._processedClientSequenceNumber = message.clientSequenceNumber;
         try {
+            // See commit that added this assert for more details.
+            // These calls should be made for all but chunked ops:
+            // 1) this.pendingStateManager.processPendingLocalMessage() below
+            // 2) this.resetReconnectCount() below
+            (0, core_utils_1.assert)(message.type !== messageTypes_js_1.ContainerMessageType.ChunkedOp, "we should never get here with chunked ops");
             let localOpMetadata;
-            if (local &&
-                messageWithContext.modernRuntimeMessage &&
-                message.type !== messageTypes_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,
@@ -1348,7 +1425,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) {
@@ -1394,8 +1471,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, core_utils_1.assert)(false, "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.
@@ -1625,6 +1708,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;
             }
@@ -1691,15 +1776,17 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         }
         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);
+        (0, index_js_3.wrapSummaryInChannelsTree)(summarizeResult);
         const pathPartsForChildren = [runtime_definitions_1.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,
@@ -1812,9 +1899,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
@@ -1827,10 +1914,10 @@ 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." */);
@@ -2042,7 +2129,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,
@@ -2189,7 +2276,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,
             });
@@ -2242,19 +2329,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, core_utils_1.assert)(metadata === undefined ||
+            containerRuntimeMessage.type === messageTypes_js_1.ContainerMessageType.BlobAttach, "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.
@@ -2267,7 +2353,6 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         const type = containerRuntimeMessage.type;
         const message = {
             contents: serializedContent,
-            type,
             metadata,
             localOpMetadata,
             referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
@@ -2282,6 +2367,19 @@ 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.
+                this.documentsSchemaController.onMessageSent((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.
@@ -2388,7 +2486,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 telemetry_utils_1.UsageError(errorMessage)));
                 this.opReentryCallsToReport--;
             }
             // Creating ops while processing ops can lead
@@ -2453,6 +2551,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.
@@ -2655,8 +2758,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         }
     }
     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;