@fluidframework/container-runtime 2.23.0 → 2.31.0

package/lib/containerRuntime.js

@@ -2,15 +2,15 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { Trace, TypedEventEmitter, } from "@fluid-internal/client-utils";
-import { AttachState, } from "@fluidframework/container-definitions";
-import { LoaderHeader, isIDeltaManagerFull, } from "@fluidframework/container-definitions/internal";
+import { Trace, TypedEventEmitter } from "@fluid-internal/client-utils";
+import { AttachState } from "@fluidframework/container-definitions";
+import { isIDeltaManagerFull } from "@fluidframework/container-definitions/internal";
 import { assert, Deferred, LazyPromise, PromiseCache, delay, } from "@fluidframework/core-utils/internal";
-import { SummaryType, } from "@fluidframework/driver-definitions";
-import { DriverHeader, FetchSource, MessageType, } from "@fluidframework/driver-definitions/internal";
+import { SummaryType } from "@fluidframework/driver-definitions";
+import { FetchSource, MessageType } from "@fluidframework/driver-definitions/internal";
 import { readAndParse } from "@fluidframework/driver-utils/internal";
 import { FlushMode, FlushModeExperimental, channelsTreeName, gcTreeKey, } from "@fluidframework/runtime-definitions/internal";
-import { GCDataBuilder, RequestParser, TelemetryContext, addBlobToSummary, addSummarizeResultToSummary, calculateStats, create404Response, exceptionToResponse, responseToException, seqFromTree, } from "@fluidframework/runtime-utils/internal";
+import { GCDataBuilder, RequestParser, TelemetryContext, addBlobToSummary, addSummarizeResultToSummary, calculateStats, create404Response, exceptionToResponse, seqFromTree, } from "@fluidframework/runtime-utils/internal";
 import { DataCorruptionError, DataProcessingError, extractSafePropertiesFromMessage, GenericError, LoggingError, PerformanceEvent, 
 // eslint-disable-next-line import/no-deprecated
 TaggedLoggerAdapter, UsageError, createChildLogger, createChildMonitoringContext, createSampledLogger, loggerToMonitoringContext, raiseConnectedEvent, wrapError, tagCodeArtifacts, } from "@fluidframework/telemetry-utils/internal";
@@ -24,20 +24,16 @@ import { channelToDataStore } from "./dataStore.js";
 import { FluidDataStoreRegistry } from "./dataStoreRegistry.js";
 import { DeltaManagerPendingOpsProxy, DeltaManagerSummarizerProxy, } from "./deltaManagerProxies.js";
 import { DeltaScheduler } from "./deltaScheduler.js";
-import { 
-// eslint-disable-next-line import/no-deprecated
-GCNodeType, GarbageCollector, gcGenerationOptionName, } from "./gc/index.js";
+import { GCNodeType, GarbageCollector, gcGenerationOptionName, } from "./gc/index.js";
 import { InboundBatchAggregator } from "./inboundBatchAggregator.js";
-import { RuntimeCompatDetails, validateLoaderCompatibility } from "./layerCompatState.js";
 import { ContainerMessageType, } from "./messageTypes.js";
 import { DuplicateBatchDetector, ensureContentsDeserialized, OpCompressor, OpDecompressor, OpGroupingManager, OpSplitter, Outbox, RemoteMessageProcessor, serializeOpContents, } from "./opLifecycle/index.js";
 import { pkgVersion } from "./packageVersion.js";
 import { PendingStateManager, } from "./pendingStateManager.js";
-import { 
-// eslint-disable-next-line import/no-deprecated
-DocumentsSchemaController, OrderedClientCollection, OrderedClientElection, RetriableSummaryError, RunWhileConnectedCoordinator, 
-// eslint-disable-next-line import/no-deprecated
-Summarizer, SummarizerClientElection, SummaryCollection, SummaryManager, aliasBlobName, chunksBlobName, recentBatchInfoBlobName, createRootSummarizerNodeWithGC, electedSummarizerBlobName, extractSummaryMetadataMessage, idCompressorBlobName, metadataBlobName, rootHasIsolatedChannels, summarizerClientType, wrapSummaryInChannelsTree, } from "./summary/index.js";
+import { RunCounter } from "./runCounter.js";
+import { runtimeCompatDetailsForLoader, validateLoaderCompatibility, } from "./runtimeLayerCompatState.js";
+import { SignalTelemetryManager } from "./signalTelemetryProcessing.js";
+import { DocumentsSchemaController, OrderedClientCollection, OrderedClientElection, RetriableSummaryError, RunWhileConnectedCoordinator, Summarizer, SummarizerClientElection, SummaryCollection, SummaryManager, aliasBlobName, chunksBlobName, recentBatchInfoBlobName, createRootSummarizerNodeWithGC, electedSummarizerBlobName, extractSummaryMetadataMessage, idCompressorBlobName, metadataBlobName, rootHasIsolatedChannels, summarizerClientType, wrapSummaryInChannelsTree, formCreateSummarizerFn, summarizerRequestUrl, validateSummaryHeuristicConfiguration, DefaultSummaryConfiguration, isSummariesDisabled, } from "./summary/index.js";
 import { Throttler, formExponentialFn } from "./throttler.js";
 /**
  * Creates an error object to be thrown / passed to Container's close fn in case of an unknown message type.
@@ -58,32 +54,9 @@ function getUnknownMessageTypeError(unknownContainerRuntimeMessageType, codePath
         },
     });
 }
-export function isSummariesDisabled(config) {
-    return config.state === "disabled";
-}
-/**
- * @legacy
- * @alpha
- */
-export const DefaultSummaryConfiguration = {
-    state: "enabled",
-    minIdleTime: 0,
-    maxIdleTime: 30 * 1000, // 30 secs.
-    maxTime: 60 * 1000, // 1 min.
-    maxOps: 100, // Summarize if 100 weighted ops received since last snapshot.
-    minOpsForLastSummaryAttempt: 10,
-    maxAckWaitTime: 3 * 60 * 1000, // 3 mins.
-    maxOpsSinceLastSummary: 7000,
-    initialSummarizerDelayMs: 5 * 1000, // 5 secs.
-    nonRuntimeOpWeight: 0.1,
-    runtimeOpWeight: 1,
-    nonRuntimeHeuristicThreshold: 20,
-};
 /**
  * Error responses when requesting a deleted object will have this header set to true
- * @legacy
- * @alpha
- * @deprecated This type will be moved to internal in 2.30. External usage is not necessary or supported.
+ * @internal
  */
 export const DeletedResponseHeaderKey = "wasDeleted";
 /**
@@ -199,55 +172,13 @@ export const makeLegacySendBatchFn = (submitFn, deltaManager) => (batch) => {
     deltaManager.flush();
     return clientSequenceNumber;
 };
-const summarizerRequestUrl = "_summarizer";
-/**
- * Create and retrieve the summmarizer
- */
-async function createSummarizer(loader, url) {
-    const request = {
-        headers: {
-            [LoaderHeader.cache]: false,
-            [LoaderHeader.clientDetails]: {
-                capabilities: { interactive: false },
-                type: summarizerClientType,
-            },
-            [DriverHeader.summarizingClient]: true,
-            [LoaderHeader.reconnect]: false,
-        },
-        url,
-    };
-    const resolvedContainer = await loader.resolve(request);
-    let fluidObject;
-    // Older containers may not have the "getEntryPoint" API
-    // ! This check will need to stay until LTS of loader moves past 2.0.0-internal.7.0.0
-    if (resolvedContainer.getEntryPoint === undefined) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any
-        const response = (await resolvedContainer.request({
-            url: `/${summarizerRequestUrl}`,
-        }));
-        if (response.status !== 200 || response.mimeType !== "fluid/object") {
-            throw responseToException(response, request);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        fluidObject = response.value;
-    }
-    else {
-        fluidObject = await resolvedContainer.getEntryPoint();
-    }
-    if (fluidObject?.ISummarizer === undefined) {
-        throw new UsageError("Fluid object does not implement ISummarizer");
-    }
-    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(
-// eslint-disable-next-line import/no-deprecated
-metadata) {
+function lastMessageFromMetadata(metadata) {
     return metadata?.documentSchema?.runtime?.explicitSchemaControl
         ? metadata?.lastMessage
         : metadata?.message;
@@ -279,7 +210,6 @@ export async function loadContainerRuntime(params) {
     return ContainerRuntime.loadRuntime(params);
 }
 const defaultMaxConsecutiveReconnects = 7;
-const defaultTelemetrySignalSampleCount = 100;
 /**
  * Represents the runtime of the container. Contains helper functions/state of the container.
  * It will define the store level mappings.
@@ -335,15 +265,13 @@ export class ContainerRuntime extends TypedEventEmitter {
         const [chunks, recentBatchInfo, metadata, electedSummarizerData, aliases, serializedIdCompressor,] = await Promise.all([
             tryFetchBlob(chunksBlobName),
             tryFetchBlob(recentBatchInfoBlobName),
-            // eslint-disable-next-line import/no-deprecated
             tryFetchBlob(metadataBlobName),
-            // eslint-disable-next-line import/no-deprecated
             tryFetchBlob(electedSummarizerBlobName),
             tryFetchBlob(aliasBlobName),
             tryFetchBlob(idCompressorBlobName),
         ]);
         // read snapshot blobs needed for BlobManager to load
-        const blobManagerSnapshot = await loadBlobManagerLoadInfo(context);
+        const blobManagerLoadInfo = await loadBlobManagerLoadInfo(context);
         const messageAtLastSummary = lastMessageFromMetadata(metadata);
         // Verify summary runtime sequence number matches protocol sequence number.
         const runtimeSequenceNumber = messageAtLastSummary?.sequenceNumber;
@@ -447,7 +375,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         };
         const compressionLz4 = compressionOptions.minimumBatchSizeInBytes !== Number.POSITIVE_INFINITY &&
             compressionOptions.compressionAlgorithm === "lz4";
-        // eslint-disable-next-line import/no-deprecated
         const documentSchemaController = new DocumentsSchemaController(existing, protocolSequenceNumber, metadata?.documentSchema, {
             explicitSchemaControl,
             compressionLz4,
@@ -475,7 +402,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             enableGroupedBatching,
             explicitSchemaControl,
         };
-        const runtime = new containerRuntimeCtor(context, registry, metadata, electedSummarizerData, chunks ?? [], aliases ?? [], internalRuntimeOptions, containerScope, logger, existing, blobManagerSnapshot, context.storage, createIdCompressorFn, documentSchemaController, featureGatesForTelemetry, provideEntryPoint, requestHandler, undefined, // summaryConfiguration
+        const runtime = new containerRuntimeCtor(context, registry, metadata, electedSummarizerData, chunks ?? [], aliases ?? [], internalRuntimeOptions, containerScope, logger, existing, blobManagerLoadInfo, context.storage, createIdCompressorFn, documentSchemaController, featureGatesForTelemetry, provideEntryPoint, requestHandler, undefined, // summaryConfiguration
         recentBatchInfo);
         runtime.blobManager.stashedBlobsUploadP.then(() => {
             // make sure we didn't reconnect before the promise resolved
@@ -559,18 +486,10 @@ export class ContainerRuntime extends TypedEventEmitter {
      * Invokes the given callback and expects that no ops are submitted
      * until execution finishes. If an op is submitted, an error will be raised.
      *
-     * Can be disabled by feature gate `Fluid.ContainerRuntime.DisableOpReentryCheck`
-     *
      * @param callback - the callback to be invoked
      */
     ensureNoDataModelChanges(callback) {
-        this.ensureNoDataModelChangesCalls++;
-        try {
-            return callback();
-        }
-        finally {
-            this.ensureNoDataModelChangesCalls--;
-        }
+        return this.dataModelChangeRunner.run(callback);
     }
     get connected() {
         return this._connected;
@@ -600,27 +519,23 @@ export class ContainerRuntime extends TypedEventEmitter {
     get gcThrowOnTombstoneUsage() {
         return false;
     }
+    /**
+     * The compatibility details of the Runtime layer that is exposed to the Loader layer
+     * for validating Loader-Runtime compatibility.
+     */
     get ILayerCompatDetails() {
-        return RuntimeCompatDetails;
+        return runtimeCompatDetailsForLoader;
     }
     /***/
-    constructor(context, registry, 
-    // eslint-disable-next-line import/no-deprecated
-    metadata, 
-    // eslint-disable-next-line import/no-deprecated
-    electedSummarizerData, chunks, dataStoreAliasMap, baseRuntimeOptions, containerScope, 
+    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, 
     // Create a custom ITelemetryBaseLogger to output telemetry events.
-    baseLogger, existing, 
-    // eslint-disable-next-line import/no-deprecated
-    blobManagerSnapshot, _storage, createIdCompressor, 
-    // eslint-disable-next-line import/no-deprecated
-    documentsSchemaController, featureGatesForTelemetry, provideEntryPoint, requestHandler, 
+    baseLogger, existing, blobManagerLoadInfo, _storage, createIdCompressor, documentsSchemaController, featureGatesForTelemetry, provideEntryPoint, requestHandler, 
     // eslint-disable-next-line unicorn/no-object-as-default-parameter
     summaryConfiguration = {
         // the defaults
         ...DefaultSummaryConfiguration,
         // the runtime configuration overrides
-        ...baseRuntimeOptions.summaryOptions?.summaryConfigOverrides,
+        ...runtimeOptions.summaryOptions?.summaryConfigOverrides,
     }, recentBatchInfo) {
         super();
         this.registry = registry;
@@ -635,23 +550,13 @@ export class ContainerRuntime extends TypedEventEmitter {
         // We accumulate Id compressor Ops while Id compressor is not loaded yet (only for "delayed" mode)
         // Once it loads, it will process all such ops and we will stop accumulating further ops - ops will be processes as they come in.
         this.pendingIdCompressorOps = [];
-        this._orderSequentiallyCalls = 0;
+        this.batchRunner = new RunCounter();
         this.flushTaskExists = false;
         this.consecutiveReconnects = 0;
-        this.ensureNoDataModelChangesCalls = 0;
+        this.dataModelChangeRunner = new RunCounter();
         this._disposed = false;
         this.emitDirtyDocumentEvent = true;
-        this._signalTracking = {
-            totalSignalsSentInLatencyWindow: 0,
-            signalsLost: 0,
-            signalsOutOfOrder: 0,
-            signalsSentSinceLastLatencyMeasurement: 0,
-            broadcastSignalSequenceNumber: 0,
-            signalTimestamp: 0,
-            roundTripSignalSequenceNumber: undefined,
-            trackingSignalSequenceNumber: undefined,
-            minimumTrackingSignalSequenceNumber: undefined,
-        };
+        this.signalTelemetryManager = new SignalTelemetryManager();
         /**
          * 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.
@@ -663,13 +568,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         const { options, clientDetails, connected, baseSnapshot, submitFn, submitBatchFn, submitSummaryFn, submitSignalFn, disposeFn, closeFn, deltaManager, quorum, audience, loader, pendingLocalState, supportedFeatures, snapshotWithContents, } = context;
         // In old loaders without dispose functionality, closeFn is equivalent but will also switch container to readonly mode
         this.disposeFn = disposeFn ?? closeFn;
-        const maybeLoaderCompatDetails = context;
-        validateLoaderCompatibility(maybeLoaderCompatDetails.ILayerCompatDetails, this.disposeFn);
-        // Backfill in defaults for the internal runtimeOptions, since they may not be present on the provided runtimeOptions object
-        const runtimeOptions = {
-            flushMode: defaultFlushMode,
-            ...baseRuntimeOptions,
-        };
+        // Validate that the Loader is compatible with this Runtime.
+        const maybeloaderCompatDetailsForRuntime = context;
+        validateLoaderCompatibility(maybeloaderCompatDetailsForRuntime.ILayerCompatDetails, this.disposeFn);
         this.mc = createChildMonitoringContext({
             logger: this.baseLogger,
             namespace: "ContainerRuntime",
@@ -717,6 +618,22 @@ export class ContainerRuntime extends TypedEventEmitter {
         // customer should observe dirty state on the runtime (the owner of dirty state) directly, rather than on the IContainer.
         this.on("dirty", () => context.updateDirtyContainerState(true));
         this.on("saved", () => context.updateDirtyContainerState(false));
+        // Telemetry for when the container is attached and subsequently saved for the first time.
+        // These events are useful for investigating the validity of container "saved" eventing upon attach.
+        // See this.setAttachState() and this.updateDocumentDirtyState() for more details on "attached" and "saved" events.
+        this.once("attached", () => {
+            this.mc.logger.sendTelemetryEvent({
+                eventName: "Attached",
+                details: {
+                    dirtyContainer: this.dirtyContainer,
+                    hasPendingMessages: this.hasPendingMessages(),
+                },
+            });
+        });
+        this.once("saved", () => this.mc.logger.sendTelemetryEvent({
+            eventName: "Saved",
+            details: { attachState: this.attachState },
+        }));
         // In cases of summarizer, we want to dispose instead since consumer doesn't interact with this container
         this.closeFn = isSummarizerClient ? this.disposeFn : closeFn;
         let loadSummaryNumber;
@@ -781,7 +698,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         this._deltaManager = outerDeltaManager;
         this.handleContext = new ContainerFluidHandleContext("", this);
         if (summaryConfiguration.state === "enabled") {
-            this.validateSummaryHeuristicConfiguration(summaryConfiguration);
+            validateSummaryHeuristicConfiguration(summaryConfiguration);
         }
         this.summariesDisabled = isSummariesDisabled(summaryConfiguration);
         const { maxOpsSinceLastSummary = 0, initialSummarizerDelayMs = 0 } = isSummariesDisabled(summaryConfiguration)
@@ -798,7 +715,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.mc.config.getNumber(maxConsecutiveReconnectsKey) ?? defaultMaxConsecutiveReconnects;
         // If the context has ILayerCompatDetails, it supports referenceSequenceNumbers since that features
         // predates ILayerCompatDetails.
-        const referenceSequenceNumbersSupported = maybeLoaderCompatDetails.ILayerCompatDetails === undefined
+        const referenceSequenceNumbersSupported = maybeloaderCompatDetailsForRuntime.ILayerCompatDetails === undefined
             ? supportedFeatures?.get("referenceSequenceNumbers") === true
             : true;
         if (runtimeOptions.flushMode === FlushModeExperimental.Async &&
@@ -879,9 +796,14 @@ export class ContainerRuntime extends TypedEventEmitter {
         // what is the interface of passing signals, we need the
         // downstream stores to wrap the signal.
         parentContext.submitSignal = (type, content, targetClientId) => {
+            // Future: Can the `content` argument type be IEnvelope?
+            // verifyNotClosed is called in FluidDataStoreContext, which is *the* expected caller.
             const envelope1 = content;
-            const envelope2 = this.createNewSignalEnvelope(envelope1.address, type, envelope1.contents);
-            return this.submitEnvelopedSignal(envelope2, targetClientId);
+            const envelope2 = createNewSignalEnvelope(envelope1.address, type, envelope1.contents);
+            if (targetClientId === undefined) {
+                this.signalTelemetryManager.applyTrackingToBroadcastSignalEnvelope(envelope2);
+            }
+            this.submitSignalFn(envelope2, targetClientId);
         };
         let snapshot = getSummaryForDatastores(baseSnapshot, metadata);
         if (snapshot !== undefined && snapshotWithContents !== undefined) {
@@ -896,8 +818,8 @@ export class ContainerRuntime extends TypedEventEmitter {
         }), (path) => this.garbageCollector.isNodeDeleted(path), new Map(dataStoreAliasMap), async (runtime) => provideEntryPoint);
         this.blobManager = new BlobManager({
             routeContext: this.handleContext,
-            snapshot: blobManagerSnapshot,
-            getStorage: () => this.storage,
+            blobManagerLoadInfo,
+            storage: this.storage,
             sendBlobAttachOp: (localId, blobId) => {
                 if (!this.disposed) {
                     this.submit({ type: ContainerMessageType.BlobAttach, contents: undefined }, undefined, {
@@ -917,8 +839,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         });
         this.deltaScheduler = new DeltaScheduler(this.innerDeltaManager, this, createChildLogger({ logger: this.baseLogger, namespace: "DeltaScheduler" }));
         this.inboundBatchAggregator = new InboundBatchAggregator(this.innerDeltaManager, () => this.clientId, createChildLogger({ logger: this.baseLogger, namespace: "InboundBatchAggregator" }));
-        const disablePartialFlush = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisablePartialFlush");
         const legacySendBatchFn = makeLegacySendBatchFn(submitFn, this.innerDeltaManager);
+        this.disableFlushBeforeProcess =
+            this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableFlushBeforeProcess") === true;
         this.outbox = new Outbox({
             shouldSend: () => this.canSendOps(),
             pendingStateManager: this.pendingStateManager,
@@ -929,16 +852,18 @@ export class ContainerRuntime extends TypedEventEmitter {
             config: {
                 compressionOptions,
                 maxBatchSizeInBytes: runtimeOptions.maxBatchSizeInBytes,
-                disablePartialFlush: disablePartialFlush === true,
+                // If we disable flush before process, we must be ready to flush partial batches
+                flushPartialBatches: this.disableFlushBeforeProcess,
             },
             logger: this.mc.logger,
             groupingManager: opGroupingManager,
             getCurrentSequenceNumbers: () => ({
+                // Note: These sequence numbers only change when DeltaManager processes an incoming op
                 referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
                 clientSequenceNumber: this._processedClientSequenceNumber,
             }),
             reSubmit: this.reSubmit.bind(this),
-            opReentrancy: () => this.ensureNoDataModelChangesCalls > 0,
+            opReentrancy: () => this.dataModelChangeRunner.running,
             closeContainer: this.closeFn,
         });
         this._quorum = quorum;
@@ -985,10 +910,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             const orderedClientElectionForSummarizer = new OrderedClientElection(orderedClientLogger, orderedClientCollection, electedSummarizerData ?? this.innerDeltaManager.lastSequenceNumber, SummarizerClientElection.isClientEligible, this.mc.config.getBoolean("Fluid.ContainerRuntime.OrderedClientElection.EnablePerformanceEvents"));
             this.summarizerClientElection = new SummarizerClientElection(orderedClientLogger, summaryCollection, orderedClientElectionForSummarizer, maxOpsSinceLastSummary);
             if (isSummarizerClient) {
-                // eslint-disable-next-line import/no-deprecated
-                this._summarizer = new Summarizer(this /* ISummarizerRuntime */, () => summaryConfiguration, this /* ISummarizerInternalsProvider */, this.handleContext, summaryCollection, 
-                // eslint-disable-next-line import/no-deprecated
-                async (runtime) => RunWhileConnectedCoordinator.create(runtime, 
+                this._summarizer = new Summarizer(this /* ISummarizerRuntime */, () => summaryConfiguration, this /* ISummarizerInternalsProvider */, this.handleContext, summaryCollection, async (runtime) => RunWhileConnectedCoordinator.create(runtime, 
                 // Summarization runs in summarizer client and needs access to the real (non-proxy) active
                 // information. The proxy delta manager would always return false for summarizer client.
                 () => this.innerDeltaManager.active));
@@ -1016,7 +938,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 summaryCollection.on("default", defaultAction);
                 // Create the SummaryManager and mark the initial state
                 this.summaryManager = new SummaryManager(this.summarizerClientElection, this, // IConnectedState
-                summaryCollection, this.baseLogger, this.formCreateSummarizerFn(loader), new Throttler(60 * 1000, // 60 sec delay window
+                summaryCollection, this.baseLogger, formCreateSummarizerFn(loader), new Throttler(60 * 1000, // 60 sec delay window
                 30 * 1000, // 30 sec max delay
                 // throttling function increases exponentially (0ms, 40ms, 80ms, 160ms, etc)
                 formExponentialFn({ coefficient: 20, initialDelay: 0 })), {
@@ -1051,14 +973,14 @@ export class ContainerRuntime extends TypedEventEmitter {
             summaryFormatVersion: metadata?.summaryFormatVersion,
             disableIsolatedChannels: metadata?.disableIsolatedChannels,
             gcVersion: metadata?.gcFeature,
-            options: JSON.stringify(baseRuntimeOptions),
+            options: JSON.stringify(runtimeOptions),
             idCompressorModeMetadata: metadata?.documentSchema?.runtime?.idCompressorMode,
             idCompressorMode: this.sessionSchema.idCompressorMode,
             sessionRuntimeSchema: JSON.stringify(this.sessionSchema),
             featureGates: JSON.stringify({
                 ...featureGatesForTelemetry,
-                disablePartialFlush,
                 closeSummarizerDelayOverride,
+                disableFlushBeforeProcess: this.disableFlushBeforeProcess,
             }),
             telemetryDocumentId: this.telemetryDocumentId,
             groupedBatchingEnabled: this.groupedBatchingEnabled,
@@ -1076,7 +998,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         // saved state, i.e. all the ops marked by Loader layer sa savedOp === true.
         this.skipSavedCompressorOps = pendingRuntimeState?.pendingIdCompressorState !== undefined;
     }
-    // eslint-disable-next-line import/no-deprecated
     onSchemaChange(schema) {
         this.mc.logger.sendTelemetryEvent({
             eventName: "SchemaChangeAccept",
@@ -1287,13 +1208,11 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
             if (id === blobManagerBasePath && requestParser.isLeaf(2)) {
                 const blob = await this.blobManager.getBlob(requestParser.pathParts[1]);
-                return blob
-                    ? {
-                        status: 200,
-                        mimeType: "fluid/object",
-                        value: blob,
-                    }
-                    : create404Response(request);
+                return {
+                    status: 200,
+                    mimeType: "fluid/object",
+                    value: blob,
+                };
             }
             else if (requestParser.pathParts.length > 0) {
                 return await this.channelCollection.request(request);
@@ -1324,7 +1243,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         const documentSchema = this.documentsSchemaController.summarizeDocumentSchema(this.deltaManager.lastSequenceNumber);
         // Is document schema explicit control on?
         const explicitSchemaControl = documentSchema?.runtime.explicitSchemaControl;
-        // eslint-disable-next-line import/no-deprecated
         const metadata = {
             ...this.createContainerMetadata,
             // Increment the summary number for the next summary that will be generated.
@@ -1338,8 +1256,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             // last message's sequence number.
             // See also lastMessageFromMetadata()
             message: explicitSchemaControl
-                ? // eslint-disable-next-line import/no-deprecated
-                    { sequenceNumber: -1 }
+                ? { sequenceNumber: -1 }
                 : message,
             lastMessage: explicitSchemaControl ? message : undefined,
             documentSchema,
@@ -1561,14 +1478,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (connected) {
             assert(this.attachState === AttachState.Attached, 0x3cd /* Connection is possible only if container exists in storage */);
             if (changeOfState) {
-                this._signalTracking.signalsLost = 0;
-                this._signalTracking.signalsOutOfOrder = 0;
-                this._signalTracking.signalTimestamp = 0;
-                this._signalTracking.signalsSentSinceLastLatencyMeasurement = 0;
-                this._signalTracking.totalSignalsSentInLatencyWindow = 0;
-                this._signalTracking.roundTripSignalSequenceNumber = undefined;
-                this._signalTracking.trackingSignalSequenceNumber = undefined;
-                this._signalTracking.minimumTrackingSignalSequenceNumber = undefined;
+                this.signalTelemetryManager.resetTracking();
             }
         }
         // Fail while disconnected
@@ -1602,6 +1512,21 @@ export class ContainerRuntime extends TypedEventEmitter {
         // spread operator above ensure we make a shallow copy of message, as the processing flow will modify it.
         // There might be multiple container instances receiving the same message.
         this.verifyNotClosed();
+        if (!this.disableFlushBeforeProcess) {
+            // Reference Sequence Number may be about to change, and it must be consistent across a batch, so flush now
+            this.outbox.flush();
+        }
+        this.ensureNoDataModelChanges(() => {
+            this.processInboundMessageOrBatch(messageCopy, local);
+        });
+    }
+    /**
+     * Implementation of core logic for {@link ContainerRuntime.process}, once preconditions are established
+     *
+     * @param messageCopy - Shallow copy of the sequenced message. If it's a virtualized batch, we'll process
+     * all messages in the batch here.
+     */
+    processInboundMessageOrBatch(messageCopy, local) {
         // Whether or not the message appears to be a runtime message from an up-to-date client.
         // It may be a legacy runtime message (ie already unpacked and ContainerMessageType)
         // or something different, like a system message.
@@ -1710,9 +1635,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         try {
             if (!runtimeBatch) {
                 for (const { message } of messagesWithMetadata) {
-                    this.ensureNoDataModelChanges(() => {
-                        this.observeNonRuntimeMessage(message);
-                    });
+                    this.observeNonRuntimeMessage(message);
                 }
                 return;
             }
@@ -1732,29 +1655,23 @@ export class ContainerRuntime extends TypedEventEmitter {
             if (!groupedBatch) {
                 for (const { message, localOpMetadata } of messagesWithMetadata) {
                     updateSequenceNumbers(message);
-                    this.ensureNoDataModelChanges(() => {
-                        this.validateAndProcessRuntimeMessages(message, [
-                            {
-                                contents: message.contents,
-                                localOpMetadata,
-                                clientSequenceNumber: message.clientSequenceNumber,
-                            },
-                        ], local, savedOp);
-                        this.emit("op", message, true /* runtimeMessage */);
-                    });
+                    this.validateAndProcessRuntimeMessages(message, [
+                        {
+                            contents: message.contents,
+                            localOpMetadata,
+                            clientSequenceNumber: message.clientSequenceNumber,
+                        },
+                    ], local, savedOp);
+                    this.emit("op", message, true /* runtimeMessage */);
                 }
                 return;
             }
             let bunchedMessagesContent = [];
             let previousMessage;
             // Process the previous bunch of messages.
-            const sendBunchedMessages = () => {
+            const processBunchedMessages = () => {
                 assert(previousMessage !== undefined, 0xa67 /* previous message must exist */);
-                this.ensureNoDataModelChanges(() => {
-                    this.validateAndProcessRuntimeMessages(
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    previousMessage, bunchedMessagesContent, local, savedOp);
-                });
+                this.validateAndProcessRuntimeMessages(previousMessage, bunchedMessagesContent, local, savedOp);
                 bunchedMessagesContent = [];
             };
             /**
@@ -1765,7 +1682,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             for (const { message, localOpMetadata } of messagesWithMetadata) {
                 const currentMessage = updateSequenceNumbers(message);
                 if (previousMessage && previousMessage.type !== currentMessage.type) {
-                    sendBunchedMessages();
+                    processBunchedMessages();
                 }
                 previousMessage = currentMessage;
                 bunchedMessagesContent.push({
@@ -1775,7 +1692,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 });
             }
             // Process the last bunch of messages.
-            sendBunchedMessages();
+            processBunchedMessages();
             // Send the "op" events for the messages now that the ops have been processed.
             for (const { message } of messagesWithMetadata) {
                 this.emit("op", message, true /* runtimeMessage */);
@@ -1867,9 +1784,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 break;
             }
             case ContainerMessageType.DocumentSchemaChange: {
-                this.documentsSchemaController.processDocumentSchemaMessages(
-                // eslint-disable-next-line import/no-deprecated
-                contents, local, message.sequenceNumber);
+                this.documentsSchemaController.processDocumentSchemaMessages(contents, local, message.sequenceNumber);
                 break;
             }
             default: {
@@ -1899,90 +1814,6 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
         }
     }
-    /**
-     * Emits the Signal event and update the perf signal data.
-     */
-    sendSignalTelemetryEvent() {
-        const duration = Date.now() - this._signalTracking.signalTimestamp;
-        this.mc.logger.sendPerformanceEvent({
-            eventName: "SignalLatency",
-            details: {
-                duration, // Roundtrip duration of the tracked signal in milliseconds.
-                sent: this._signalTracking.totalSignalsSentInLatencyWindow, // Signals sent since the last logged SignalLatency event.
-                lost: this._signalTracking.signalsLost, // Signals lost since the last logged SignalLatency event.
-                outOfOrder: this._signalTracking.signalsOutOfOrder, // Out of order signals since the last logged SignalLatency event.
-                reconnectCount: this.consecutiveReconnects, // Container reconnect count.
-            },
-        });
-        this._signalTracking.signalsLost = 0;
-        this._signalTracking.signalsOutOfOrder = 0;
-        this._signalTracking.signalTimestamp = 0;
-        this._signalTracking.totalSignalsSentInLatencyWindow = 0;
-    }
-    /**
-     * Updates signal telemetry including emitting telemetry events.
-     */
-    processSignalForTelemetry(envelope) {
-        const { clientBroadcastSignalSequenceNumber, contents: envelopeContents, address: envelopeAddress, } = envelope;
-        if (clientBroadcastSignalSequenceNumber === undefined) {
-            return;
-        }
-        if (this._signalTracking.trackingSignalSequenceNumber === undefined ||
-            this._signalTracking.minimumTrackingSignalSequenceNumber === undefined) {
-            return;
-        }
-        if (clientBroadcastSignalSequenceNumber >= this._signalTracking.trackingSignalSequenceNumber) {
-            // Calculate the number of signals lost and log the event.
-            const signalsLost = clientBroadcastSignalSequenceNumber -
-                this._signalTracking.trackingSignalSequenceNumber;
-            if (signalsLost > 0) {
-                this._signalTracking.signalsLost += signalsLost;
-                this.mc.logger.sendErrorEvent({
-                    eventName: "SignalLost",
-                    details: {
-                        signalsLost, // Number of lost signals detected.
-                        expectedSequenceNumber: this._signalTracking.trackingSignalSequenceNumber, // The next expected signal sequence number.
-                        clientBroadcastSignalSequenceNumber, // Actual signal sequence number received.
-                    },
-                });
-            }
-            // Update the tracking signal sequence number to the next expected signal in the sequence.
-            this._signalTracking.trackingSignalSequenceNumber =
-                clientBroadcastSignalSequenceNumber + 1;
-        }
-        else if (
-        // Check if this is a signal in range of interest.
-        clientBroadcastSignalSequenceNumber >=
-            this._signalTracking.minimumTrackingSignalSequenceNumber) {
-            this._signalTracking.signalsOutOfOrder++;
-            const details = {
-                expectedSequenceNumber: this._signalTracking.trackingSignalSequenceNumber, // The next expected signal sequence number.
-                clientBroadcastSignalSequenceNumber, // Sequence number of the out of order signal.
-            };
-            // Only log `contents.type` when address is for container to avoid
-            // chance that contents type is customer data.
-            if (envelopeAddress === undefined) {
-                details.contentsType = envelopeContents.type; // Type of signal that was received out of order.
-            }
-            this.mc.logger.sendTelemetryEvent({
-                eventName: "SignalOutOfOrder",
-                details,
-            });
-        }
-        if (this._signalTracking.roundTripSignalSequenceNumber !== undefined &&
-            clientBroadcastSignalSequenceNumber >= this._signalTracking.roundTripSignalSequenceNumber) {
-            if (clientBroadcastSignalSequenceNumber ===
-                this._signalTracking.roundTripSignalSequenceNumber) {
-                // Latency tracked signal has been received.
-                // We now log the roundtrip duration of the tracked signal.
-                // This telemetry event also logs metrics for broadcast signals
-                // sent, lost, and out of order.
-                // These metrics are reset after logging the telemetry event.
-                this.sendSignalTelemetryEvent();
-            }
-            this._signalTracking.roundTripSignalSequenceNumber = undefined;
-        }
-    }
     processSignal(message, local) {
         const envelope = message.content;
         const transformed = {
@@ -1993,7 +1824,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         };
         // Only collect signal telemetry for broadcast messages sent by the current client.
         if (message.clientId === this.clientId) {
-            this.processSignalForTelemetry(envelope);
+            this.signalTelemetryManager.trackReceivedSignal(envelope, this.mc.logger, this.consecutiveReconnects);
         }
         if (envelope.address === undefined) {
             // No address indicates a container signal message.
@@ -2017,7 +1848,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      * with the given Batch ID, which must be preserved
      */
     flush(resubmittingBatchId) {
-        assert(this._orderSequentiallyCalls === 0, 0x24c /* "Cannot call `flush()` from `orderSequentially`'s callback" */);
+        assert(!this.batchRunner.running, 0x24c /* "Cannot call `flush()` while manually accumulating a batch (e.g. under orderSequentially) */);
         this.outbox.flush(resubmittingBatchId);
         assert(this.outbox.isEmpty, 0x3cf /* reentrancy */);
     }
@@ -2026,43 +1857,45 @@ export class ContainerRuntime extends TypedEventEmitter {
      */
     orderSequentially(callback) {
         let checkpoint;
-        let result;
+        const checkpointDirtyState = this.dirtyContainer;
         if (this.mc.config.getBoolean("Fluid.ContainerRuntime.EnableRollback")) {
             // Note: we are not touching any batches other than mainBatch here, for two reasons:
             // 1. It would not help, as other batches are flushed independently from main batch.
             // 2. There is no way to undo process of data store creation, blob creation, ID compressor ops, or other things tracked by other batches.
             checkpoint = this.outbox.getBatchCheckpoints().mainBatch;
         }
-        try {
-            this._orderSequentiallyCalls++;
-            result = callback();
-        }
-        catch (error) {
-            if (checkpoint) {
-                // This will throw and close the container if rollback fails
-                try {
-                    checkpoint.rollback((message) => this.rollback(message.contents, message.localOpMetadata));
+        const result = this.batchRunner.run(() => {
+            try {
+                return callback();
+            }
+            catch (error) {
+                if (checkpoint) {
+                    // This will throw and close the container if rollback fails
+                    try {
+                        checkpoint.rollback((message) => this.rollback(message.contents, message.localOpMetadata));
+                        // reset the dirty state after rollback to what it was before to keep it consistent
+                        if (this.dirtyContainer !== checkpointDirtyState) {
+                            this.updateDocumentDirtyState(checkpointDirtyState);
+                        }
+                    }
+                    catch (error_) {
+                        const error2 = wrapError(error_, (message) => {
+                            return DataProcessingError.create(`RollbackError: ${message}`, "checkpointRollback", undefined);
+                        });
+                        this.closeFn(error2);
+                        throw error2;
+                    }
                 }
-                catch (error_) {
-                    const error2 = wrapError(error_, (message) => {
-                        return DataProcessingError.create(`RollbackError: ${message}`, "checkpointRollback", undefined);
-                    });
-                    this.closeFn(error2);
-                    throw error2;
+                else {
+                    this.closeFn(wrapError(error, (errorMessage) => new GenericError(`orderSequentially callback exception: ${errorMessage}`, error, {
+                        orderSequentiallyCalls: this.batchRunner.runs,
+                    })));
                 }
+                throw error; // throw the original error for the consumer of the runtime
             }
-            else {
-                this.closeFn(wrapError(error, (errorMessage) => new GenericError(`orderSequentially callback exception: ${errorMessage}`, error, {
-                    orderSequentiallyCalls: this._orderSequentiallyCalls,
-                })));
-            }
-            throw error; // throw the original error for the consumer of the runtime
-        }
-        finally {
-            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 !== FlushMode.TurnBased && this._orderSequentiallyCalls === 0) {
+        if (this.flushMode !== FlushMode.TurnBased && !this.batchRunner.running) {
             this.flush();
         }
         return result;
@@ -2117,7 +1950,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      * Typically ops are batched and later flushed together, but in some cases we want to flush immediately.
      */
     currentlyBatching() {
-        return this.flushMode !== FlushMode.Immediate || this._orderSequentiallyCalls !== 0;
+        return this.flushMode !== FlushMode.Immediate || this.batchRunner.running;
     }
     getQuorum() {
         return this._quorum;
@@ -2161,43 +1994,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         return true;
     }
-    createNewSignalEnvelope(address, type, content) {
-        const newEnvelope = {
-            address,
-            contents: { type, content },
-        };
-        return newEnvelope;
-    }
-    submitEnvelopedSignal(envelope, targetClientId) {
-        const isBroadcastSignal = targetClientId === undefined;
-        if (isBroadcastSignal) {
-            const clientBroadcastSignalSequenceNumber = ++this._signalTracking
-                .broadcastSignalSequenceNumber;
-            // Stamp with the broadcast signal sequence number.
-            envelope.clientBroadcastSignalSequenceNumber = clientBroadcastSignalSequenceNumber;
-            this._signalTracking.signalsSentSinceLastLatencyMeasurement++;
-            if (this._signalTracking.minimumTrackingSignalSequenceNumber === undefined ||
-                this._signalTracking.trackingSignalSequenceNumber === undefined) {
-                // Signal monitoring window is undefined
-                // Initialize tracking to expect the next signal sent by the connected client.
-                this._signalTracking.minimumTrackingSignalSequenceNumber =
-                    clientBroadcastSignalSequenceNumber;
-                this._signalTracking.trackingSignalSequenceNumber =
-                    clientBroadcastSignalSequenceNumber;
-            }
-            // We should not track the round trip of a new signal in the case we are already tracking one.
-            if (clientBroadcastSignalSequenceNumber % defaultTelemetrySignalSampleCount === 1 &&
-                this._signalTracking.roundTripSignalSequenceNumber === undefined) {
-                this._signalTracking.signalTimestamp = Date.now();
-                this._signalTracking.roundTripSignalSequenceNumber =
-                    clientBroadcastSignalSequenceNumber;
-                this._signalTracking.totalSignalsSentInLatencyWindow +=
-                    this._signalTracking.signalsSentSinceLastLatencyMeasurement;
-                this._signalTracking.signalsSentSinceLastLatencyMeasurement = 0;
-            }
-        }
-        this.submitSignalFn(envelope, targetClientId);
-    }
     /**
      * Submits the signal to be sent to other clients.
      * @param type - Type of the signal.
@@ -2212,8 +2008,11 @@ export class ContainerRuntime extends TypedEventEmitter {
      */
     submitSignal(type, content, targetClientId) {
         this.verifyNotClosed();
-        const envelope = this.createNewSignalEnvelope(undefined /* address */, type, content);
-        return this.submitEnvelopedSignal(envelope, targetClientId);
+        const envelope = createNewSignalEnvelope(undefined /* address */, type, content);
+        if (targetClientId === undefined) {
+            this.signalTelemetryManager.applyTrackingToBroadcastSignalEnvelope(envelope);
+        }
+        this.submitSignalFn(envelope, targetClientId);
     }
     setAttachState(attachState) {
         if (attachState === AttachState.Attaching) {
@@ -2367,13 +2166,10 @@ export class ContainerRuntime extends TypedEventEmitter {
      * Returns the type of the GC node. Currently, there are nodes that belong to the root ("/"), data stores or
      * blob manager.
      */
-    // eslint-disable-next-line import/no-deprecated
     getNodeType(nodePath) {
         if (isBlobPath(nodePath)) {
-            // eslint-disable-next-line import/no-deprecated
             return GCNodeType.Blob;
         }
-        // eslint-disable-next-line import/no-deprecated
         return this.channelCollection.getGCNodeType(nodePath) ?? GCNodeType.Other;
     }
     /**
@@ -2387,13 +2183,10 @@ export class ContainerRuntime extends TypedEventEmitter {
             return ["_gcRoot"];
         }
         switch (this.getNodeType(nodePath)) {
-            // eslint-disable-next-line import/no-deprecated
             case GCNodeType.Blob: {
                 return [blobManagerBasePath];
             }
-            // eslint-disable-next-line import/no-deprecated
             case GCNodeType.DataStore:
-            // eslint-disable-next-line import/no-deprecated
             case GCNodeType.SubDataStore: {
                 return this.channelCollection.getDataStorePackagePath(nodePath);
             }
@@ -2461,7 +2254,6 @@ export class ContainerRuntime extends TypedEventEmitter {
      * op processing, updating SummarizerNode state tracking, and garbage collection.
      * @param options - options controlling how the summary is generated or submitted
      */
-    // eslint-disable-next-line import/no-deprecated
     async submitSummary(options) {
         const { cancellationToken, fullTree = false, finalAttempt = false, summaryLogger, latestSummaryRefSeqNum, } = options;
         // The summary number for this summary. This will be updated during the summary process, so get it now and
@@ -2950,7 +2742,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 break;
             }
             default: {
-                assert(this._orderSequentiallyCalls > 0, 0x587 /* Unreachable unless running under orderSequentially */);
+                assert(this.batchRunner.running, 0x587 /* Unreachable unless manually accumulating a batch */);
                 break;
             }
         }
@@ -2978,7 +2770,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      * for correlation to detect container forking.
      */
     reSubmitBatch(batch, batchId) {
-        this.orderSequentially(() => {
+        this.batchRunner.run(() => {
             for (const message of batch) {
                 this.reSubmit(message);
             }
@@ -3063,7 +2855,6 @@ export class ContainerRuntime extends TypedEventEmitter {
     /**
      * Implementation of ISummarizerInternalsProvider.refreshLatestSummaryAck
      */
-    // eslint-disable-next-line import/no-deprecated
     async refreshLatestSummaryAck(options) {
         const { proposalHandle, ackHandle, summaryRefSeq, summaryLogger } = options;
         // proposalHandle is always passed from RunningSummarizer.
@@ -3160,8 +2951,8 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     getPendingLocalState(props) {
         this.verifyNotClosed();
-        if (this._orderSequentiallyCalls !== 0) {
-            throw new UsageError("can't get state during orderSequentially");
+        if (this.batchRunner.running) {
+            throw new UsageError("can't get state while manually accumulating a batch");
         }
         this.imminentClosure ||= props?.notifyImminentClosure ?? false;
         const getSyncState = (pendingAttachmentBlobs) => {
@@ -3222,27 +3013,15 @@ export class ContainerRuntime extends TypedEventEmitter {
             return this.summaryManager.enqueueSummarize(options);
         }
     }
-    /**
-     * Forms a function that will create and retrieve a Summarizer.
-     */
-    formCreateSummarizerFn(loader) {
-        return async () => {
-            return createSummarizer(loader, `/${summarizerRequestUrl}`);
-        };
-    }
-    validateSummaryHeuristicConfiguration(configuration) {
-        // eslint-disable-next-line no-restricted-syntax
-        for (const prop in configuration) {
-            if (typeof configuration[prop] === "number" && configuration[prop] < 0) {
-                throw new UsageError(`Summary heuristic configuration property "${prop}" cannot be less than 0`);
-            }
-        }
-        if (configuration.minIdleTime > configuration.maxIdleTime) {
-            throw new UsageError(`"minIdleTime" [${configuration.minIdleTime}] cannot be greater than "maxIdleTime" [${configuration.maxIdleTime}]`);
-        }
-    }
     get groupedBatchingEnabled() {
         return this.sessionSchema.opGroupingEnabled === true;
     }
 }
+export function createNewSignalEnvelope(address, type, content) {
+    const newEnvelope = {
+        address,
+        contents: { type, content },
+    };
+    return newEnvelope;
+}
 //# sourceMappingURL=containerRuntime.js.map