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

package/dist/containerRuntime.js

@@ -7,13 +7,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 driver_definitions_1 = require("@fluidframework/driver-definitions");
-const driver_utils_1 = require("@fluidframework/driver-utils");
+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 telemetry_utils_1 = require("@fluidframework/telemetry-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 batchTracker_js_1 = require("./batchTracker.js");
 const blobManager_js_1 = require("./blobManager.js");
@@ -91,7 +92,7 @@ exports.disabledCompressionConfig = {
     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
@@ -164,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_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,
     };
@@ -186,12 +187,12 @@ 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;
 }
@@ -233,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: {
@@ -242,7 +244,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 },
             },
         });
-        const mc = (0, telemetry_utils_1.loggerToMonitoringContext)(logger);
+        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) => {
@@ -250,8 +252,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             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([
@@ -265,8 +267,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         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.
@@ -284,7 +286,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 // 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") {
@@ -295,6 +297,18 @@ 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.
         let idCompressorMode;
@@ -306,27 +320,22 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             // 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" 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
+            // 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?.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!
+            if (idCompressorMode === undefined && desiredIdCompressorMode === "delayed") {
+                idCompressorMode = desiredIdCompressorMode;
+            }
         }
         else {
-            switch (mc.config.getBoolean("Fluid.ContainerRuntime.IdCompressorEnabled")) {
-                case true:
-                    idCompressorMode = "on";
-                    break;
-                case false:
-                    idCompressorMode = undefined;
-                    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.
@@ -339,7 +348,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);
@@ -362,6 +371,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             compressionLz4,
             idCompressorMode,
             opGroupingEnabled,
+            disallowedVersions: [],
         }, (schema) => {
             runtime.onSchemaChange(schema);
         });
@@ -383,6 +393,13 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             enableGroupedBatching,
             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);
@@ -426,7 +443,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;
         }
     }
@@ -467,7 +484,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() {
@@ -543,11 +560,11 @@ 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, telemetry_utils_1.createChildMonitoringContext)({
+        this.mc = (0, internal_7.createChildMonitoringContext)({
             logger: this.logger,
             namespace: "ContainerRuntime",
         });
@@ -651,11 +668,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;
@@ -668,7 +685,7 @@ 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_1.GarbageCollector.create({
@@ -682,12 +699,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_3.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
@@ -717,15 +734,25 @@ 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,
@@ -781,7 +808,7 @@ 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",
             });
@@ -858,9 +885,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);
@@ -891,10 +918,10 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     }
     /* 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, core_utils_1.assert)(false, 0x909 /* should not be called */);
+        (0, internal_2.assert)(false, 0x909 /* should not be called */);
     }
     /**
      * Initializes the state from the base snapshot this container runtime loaded from.
@@ -903,7 +930,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();
@@ -937,13 +964,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,
@@ -961,14 +988,14 @@ 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_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,
@@ -991,7 +1018,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
@@ -999,7 +1026,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);
@@ -1022,7 +1049,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];
         }
@@ -1036,7 +1063,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) {
@@ -1046,16 +1073,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);
         }
     }
     /**
@@ -1064,7 +1091,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
@@ -1078,15 +1105,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);
         }
     }
     /**
@@ -1125,35 +1152,35 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             lastMessage: explitiSchemaControl ? message : undefined,
             documentSchema,
         };
-        (0, runtime_utils_1.addBlobToSummary)(summaryTree, index_js_3.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_3.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_3.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_3.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_3.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_3.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.
@@ -1198,7 +1225,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 {
@@ -1220,9 +1247,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) {
@@ -1234,7 +1261,16 @@ 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 !== undefined, 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;
@@ -1246,14 +1282,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,
@@ -1274,6 +1310,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             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);
                 }
@@ -1306,23 +1343,16 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // 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;
@@ -1340,13 +1370,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,
@@ -1359,7 +1389,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);
@@ -1408,7 +1438,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             // 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");
+            (0, internal_2.assert)(message.type !== messageTypes_js_1.ContainerMessageType.ChunkedOp, "we should never get here with chunked ops");
             let localOpMetadata;
             if (local && messageWithContext.modernRuntimeMessage) {
                 localOpMetadata = this.pendingStateManager.processPendingLocalMessage(messageWithContext.message);
@@ -1459,7 +1489,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, "id compressor should be enabled");
                         this.pendingIdCompressorOps.push(range);
                     }
                     else {
@@ -1473,7 +1506,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             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");
+                (0, internal_2.assert)(false, "should not even get here");
             case messageTypes_js_1.ContainerMessageType.Rejoin:
                 break;
             case messageTypes_js_1.ContainerMessageType.DocumentSchemaChange:
@@ -1488,7 +1521,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,
@@ -1572,9 +1605,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}
@@ -1599,15 +1632,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,
                 })));
             }
@@ -1617,7 +1650,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;
@@ -1646,7 +1679,7 @@ 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;
@@ -1675,7 +1708,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;
@@ -1736,7 +1769,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) {
@@ -1746,10 +1779,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()) {
@@ -1772,6 +1805,7 @@ 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, "No other ranges should be taken while container is detached.");
             this._idCompressor?.finalizeCreationRange(idRange);
         }
         const summarizeResult = this.channelCollection.getAttachSummary(telemetryContext);
@@ -1784,7 +1818,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         const summarizeResult = await this.channelCollection.summarize(fullTree, trackState, telemetryContext);
         // Wrap data store summaries in .channels subtree.
         (0, index_js_3.wrapSummaryInChannelsTree)(summarizeResult);
-        const pathPartsForChildren = [runtime_definitions_1.channelsTreeName];
+        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);
@@ -1800,7 +1834,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,
@@ -1814,7 +1848,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 {
@@ -1842,7 +1876,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);
@@ -1920,7 +1954,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             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." */);
         }
     }
     /**
@@ -1981,16 +2015,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 } },
             }));
@@ -2074,7 +2108,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.
@@ -2084,7 +2118,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,
@@ -2148,11 +2182,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,
@@ -2263,7 +2297,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,
@@ -2296,11 +2330,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;
@@ -2338,8 +2372,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         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 ||
+        (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, "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
@@ -2370,7 +2404,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 // 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 contents = this.documentsSchemaController.maybeSendSchemaMessage();
+                if (contents) {
                     const msg = {
                         type: messageTypes_js_1.ContainerMessageType.DocumentSchemaChange,
                         contents,
@@ -2379,7 +2414,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                         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.
@@ -2443,29 +2478,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)
@@ -2486,7 +2521,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_2.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
@@ -2502,7 +2537,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);
             }
         }
     }
@@ -2527,7 +2562,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:
@@ -2568,7 +2603,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,
@@ -2598,8 +2633,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
@@ -2626,7 +2661,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, {
@@ -2642,7 +2677,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();
     }
@@ -2652,16 +2687,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);
@@ -2675,7 +2710,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) => {
@@ -2707,8 +2742,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) {
@@ -2721,7 +2756,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) {
@@ -2735,7 +2770,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}`);
         }
     }
     /**
@@ -2750,11 +2785,11 @@ 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() {