@fluidframework/container-runtime 2.0.0-internal.6.3.3 → 2.0.0-internal.7.0.0

package/dist/containerRuntime.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -19,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContainerRuntime = exports.makeLegacySendBatchFn = exports.getDeviceSpec = exports.agentSchedulerId = exports.isRuntimeMessage = exports.RuntimeMessage = exports.defaultPendingOpsRetryDelayMs = exports.defaultPendingOpsWaitTimeoutMs = exports.CompressionAlgorithms = exports.defaultRuntimeHeaderData = exports.InactiveResponseHeaderKey = exports.TombstoneResponseHeaderKey = exports.AllowInactiveRequestHeaderKey = exports.AllowTombstoneRequestHeaderKey = exports.RuntimeHeaders = exports.DefaultSummaryConfiguration = exports.ContainerMessageType = void 0;
+exports.ContainerRuntime = exports.makeLegacySendBatchFn = exports.getDeviceSpec = exports.agentSchedulerId = exports.isRuntimeMessage = exports.RuntimeMessage = exports.defaultPendingOpsRetryDelayMs = exports.defaultPendingOpsWaitTimeoutMs = exports.CompressionAlgorithms = exports.defaultRuntimeHeaderData = exports.InactiveResponseHeaderKey = exports.TombstoneResponseHeaderKey = exports.AllowInactiveRequestHeaderKey = exports.AllowTombstoneRequestHeaderKey = exports.RuntimeHeaders = exports.DefaultSummaryConfiguration = void 0;
 const container_definitions_1 = require("@fluidframework/container-definitions");
 const core_utils_1 = require("@fluidframework/core-utils");
 const client_utils_1 = require("@fluid-internal/client-utils");
@@ -45,32 +49,12 @@ const batchTracker_1 = require("./batchTracker");
 const scheduleManager_1 = require("./scheduleManager");
 const opLifecycle_1 = require("./opLifecycle");
 const deltaManagerSummarizerProxy_1 = require("./deltaManagerSummarizerProxy");
-var ContainerMessageType;
-(function (ContainerMessageType) {
-    // An op to be delivered to store
-    ContainerMessageType["FluidDataStoreOp"] = "component";
-    // Creates a new store
-    ContainerMessageType["Attach"] = "attach";
-    // Chunked operation.
-    ContainerMessageType["ChunkedOp"] = "chunkedOp";
-    // Signifies that a blob has been attached and should not be garbage collected by storage
-    ContainerMessageType["BlobAttach"] = "blobAttach";
-    // Ties our new clientId to our old one on reconnect
-    ContainerMessageType["Rejoin"] = "rejoin";
-    // Sets the alias of a root data store
-    ContainerMessageType["Alias"] = "alias";
-    /**
-     * An op containing an IdRange of Ids allocated using the runtime's IdCompressor since
-     * the last allocation op was sent.
-     * See the [IdCompressor README](./id-compressor/README.md) for more details.
-     */
-    ContainerMessageType["IdAllocation"] = "idAllocation";
-})(ContainerMessageType = exports.ContainerMessageType || (exports.ContainerMessageType = {}));
+const messageTypes_1 = require("./messageTypes");
 /**
  * Utility to implement compat behaviors given an unknown message type
  * The parameters are typed to support compile-time enforcement of handling all known types/behaviors
  *
- * @param _unknownContainerRuntimeMessageType - Typed as never, to ensure all known types have been
+ * @param _unknownContainerRuntimeMessageType - Typed as something unexpected, to ensure all known types have been
  * handled before calling this function (e.g. in a switch statement).
  * @param compatBehavior - Typed redundantly with CompatModeBehavior to ensure handling is added when updating that type
  */
@@ -78,6 +62,12 @@ function compatBehaviorAllowsMessageType(_unknownContainerRuntimeMessageType, co
     // undefined defaults to same behavior as "FailToProcess"
     return compatBehavior === "Ignore";
 }
+function prepareLocalContainerRuntimeIdAllocationMessageForTransit(message) {
+    // Remove the stashedState from the op if it's a stashed op
+    if ("stashedState" in message.contents) {
+        delete message.contents.stashedState;
+    }
+}
 exports.DefaultSummaryConfiguration = {
     state: "enabled",
     minIdleTime: 0,
@@ -101,7 +91,7 @@ var RuntimeHeaders;
     RuntimeHeaders["wait"] = "wait";
     /** True if the request is coming from an IFluidHandle. */
     RuntimeHeaders["viaHandle"] = "viaHandle";
-})(RuntimeHeaders = exports.RuntimeHeaders || (exports.RuntimeHeaders = {}));
+})(RuntimeHeaders || (exports.RuntimeHeaders = RuntimeHeaders = {}));
 /** True if a tombstoned object should be returned without erroring */
 exports.AllowTombstoneRequestHeaderKey = "allowTombstone"; // Belongs in the enum above, but avoiding the breaking change
 /** [IRRELEVANT IF throwOnInactiveLoad OPTION NOT SET] True if an inactive object should be returned without erroring */
@@ -122,7 +112,7 @@ exports.defaultRuntimeHeaderData = {
 var CompressionAlgorithms;
 (function (CompressionAlgorithms) {
     CompressionAlgorithms["lz4"] = "lz4";
-})(CompressionAlgorithms = exports.CompressionAlgorithms || (exports.CompressionAlgorithms = {}));
+})(CompressionAlgorithms || (exports.CompressionAlgorithms = CompressionAlgorithms = {}));
 const maxConsecutiveReconnectsKey = "Fluid.ContainerRuntime.MaxConsecutiveReconnects";
 const defaultFlushMode = runtime_definitions_1.FlushMode.TurnBased;
 // The actual limit is 1Mb (socket.io and Kafka limits)
@@ -147,7 +137,7 @@ exports.defaultPendingOpsRetryDelayMs = 1000;
  */
 const defaultCloseSummarizerDelayMs = 5000; // 5 seconds
 /**
- * @deprecated - use ContainerRuntimeMessage instead
+ * @deprecated - use ContainerRuntimeMessageType instead
  */
 var RuntimeMessage;
 (function (RuntimeMessage) {
@@ -158,7 +148,7 @@ var RuntimeMessage;
     RuntimeMessage["Rejoin"] = "rejoin";
     RuntimeMessage["Alias"] = "alias";
     RuntimeMessage["Operation"] = "op";
-})(RuntimeMessage = exports.RuntimeMessage || (exports.RuntimeMessage = {}));
+})(RuntimeMessage || (exports.RuntimeMessage = RuntimeMessage = {}));
 /**
  * @deprecated - please use version in driver-utils
  */
@@ -206,15 +196,227 @@ exports.makeLegacySendBatchFn = makeLegacySendBatchFn;
  * It will define the store level mappings.
  */
 class ContainerRuntime extends client_utils_1.TypedEventEmitter {
+    /**
+     * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
+    get IFluidRouter() {
+        return this;
+    }
+    /**
+     * @deprecated - use loadRuntime instead.
+     * Load the stores from a snapshot and returns the runtime.
+     * @param context - Context of the container.
+     * @param registryEntries - Mapping to the stores.
+     * @param requestHandler - Request handlers for the container runtime
+     * @param runtimeOptions - Additional options to be passed to the runtime
+     * @param existing - (optional) When loading from an existing snapshot. Precedes context.existing if provided
+     * @param containerRuntimeCtor - (optional) Constructor to use to create the ContainerRuntime instance. This
+     * allows mixin classes to leverage this method to define their own async initializer.
+     */
+    static async load(context, registryEntries, requestHandler, runtimeOptions = {}, containerScope = context.scope, existing, containerRuntimeCtor = ContainerRuntime) {
+        let existingFlag = true;
+        if (!existing) {
+            existingFlag = false;
+        }
+        return this.loadRuntime({
+            context,
+            registryEntries,
+            existing: existingFlag,
+            runtimeOptions,
+            containerScope,
+            containerRuntimeCtor,
+            requestHandler,
+            provideEntryPoint: () => {
+                throw new telemetry_utils_1.UsageError("ContainerRuntime.load is deprecated and should no longer be used");
+            },
+        });
+    }
+    /**
+     * Load the stores from a snapshot and returns the runtime.
+     * @param params - An object housing the runtime properties:
+     * - context - Context of the container.
+     * - registryEntries - Mapping from data store types to their corresponding factories.
+     * - existing - Pass 'true' if loading from an existing snapshot.
+     * - requestHandler - (optional) Request handler for the request() method of the container runtime.
+     * Only relevant for back-compat while we remove the request() method and move fully to entryPoint as the main pattern.
+     * - runtimeOptions - Additional options to be passed to the runtime
+     * - containerScope - runtime services provided with context
+     * - containerRuntimeCtor - Constructor to use to create the ContainerRuntime instance.
+     * This allows mixin classes to leverage this method to define their own async initializer.
+     * - provideEntryPoint - Promise that resolves to an object which will act as entryPoint for the Container.
+     * This object should provide all the functionality that the Container is expected to provide to the loader layer.
+     */
+    static async loadRuntime(params) {
+        const { context, registryEntries, existing, requestHandler, provideEntryPoint, runtimeOptions = {}, containerScope = {}, containerRuntimeCtor = ContainerRuntime, } = params;
+        // If taggedLogger exists, use it. Otherwise, wrap the vanilla logger:
+        // back-compat: Remove the TaggedLoggerAdapter fallback once all the host are using loader > 0.45
+        const backCompatContext = context;
+        const passLogger = backCompatContext.taggedLogger ??
+            // eslint-disable-next-line import/no-deprecated
+            new telemetry_utils_1.TaggedLoggerAdapter(backCompatContext.logger);
+        const logger = (0, telemetry_utils_1.createChildLogger)({
+            logger: passLogger,
+            properties: {
+                all: {
+                    runtimeVersion: packageVersion_1.pkgVersion,
+                },
+            },
+        });
+        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, compressionOptions = defaultCompressionConfig, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, enableRuntimeIdCompressor = false, chunkSizeInBytes = defaultChunkSizeInBytes, enableOpReentryCheck = false, enableGroupedBatching = false, } = runtimeOptions;
+        const registry = new dataStoreRegistry_1.FluidDataStoreRegistry(registryEntries);
+        const tryFetchBlob = async (blobName) => {
+            const blobId = context.baseSnapshot?.blobs[blobName];
+            if (context.baseSnapshot && blobId) {
+                // IContainerContext storage api return type still has undefined in 0.39 package version.
+                // So once we release 0.40 container-defn package we can remove this check.
+                (0, core_utils_1.assert)(context.storage !== undefined, 0x1f5 /* "Attached state should have storage" */);
+                return (0, driver_utils_1.readAndParse)(context.storage, blobId);
+            }
+        };
+        const [chunks, metadata, electedSummarizerData, aliases, serializedIdCompressor] = await Promise.all([
+            tryFetchBlob(summary_1.chunksBlobName),
+            tryFetchBlob(summary_1.metadataBlobName),
+            tryFetchBlob(summary_1.electedSummarizerBlobName),
+            tryFetchBlob(summary_1.aliasBlobName),
+            tryFetchBlob(summary_1.idCompressorBlobName),
+        ]);
+        // read snapshot blobs needed for BlobManager to load
+        const blobManagerSnapshot = await blobManager_1.BlobManager.load(context.baseSnapshot?.trees[summary_1.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);
+        });
+        // Verify summary runtime sequence number matches protocol sequence number.
+        const runtimeSequenceNumber = metadata?.message?.sequenceNumber;
+        // When we load with pending state, we reuse an old snapshot so we don't expect these numbers to match
+        if (!context.pendingLocalState && runtimeSequenceNumber !== undefined) {
+            const protocolSequenceNumber = context.deltaManager.initialSequenceNumber;
+            // Unless bypass is explicitly set, then take action when sequence numbers mismatch.
+            if (loadSequenceNumberVerification !== "bypass" &&
+                runtimeSequenceNumber !== protocolSequenceNumber) {
+                // "Load from summary, runtime metadata sequenceNumber !== initialSequenceNumber"
+                const error = new telemetry_utils_1.DataCorruptionError(
+                // pre-0.58 error message: SummaryMetadataMismatch
+                "Summary metadata mismatch", { runtimeVersion: packageVersion_1.pkgVersion, runtimeSequenceNumber, protocolSequenceNumber });
+                if (loadSequenceNumberVerification === "log") {
+                    logger.sendErrorEvent({ eventName: "SequenceNumberMismatch" }, error);
+                }
+                else {
+                    context.closeFn(error);
+                }
+            }
+        }
+        const idCompressorEnabled = metadata?.idCompressorEnabled ?? runtimeOptions.enableRuntimeIdCompressor ?? false;
+        let idCompressor;
+        if (idCompressorEnabled) {
+            const { IdCompressor, createSessionId } = await Promise.resolve().then(() => __importStar(require("./id-compressor")));
+            idCompressor =
+                serializedIdCompressor !== undefined
+                    ? IdCompressor.deserialize(serializedIdCompressor, createSessionId())
+                    : IdCompressor.create(logger);
+        }
+        const runtime = new containerRuntimeCtor(context, registry, metadata, electedSummarizerData, chunks ?? [], aliases ?? [], {
+            summaryOptions,
+            gcOptions,
+            loadSequenceNumberVerification,
+            flushMode,
+            compressionOptions,
+            maxBatchSizeInBytes,
+            chunkSizeInBytes,
+            enableRuntimeIdCompressor,
+            enableOpReentryCheck,
+            enableGroupedBatching,
+        }, containerScope, logger, existing, blobManagerSnapshot, context.storage, idCompressor, provideEntryPoint, requestHandler, undefined);
+        // Apply stashed ops with a reference sequence number equal to the sequence number of the snapshot,
+        // or zero. This must be done before Container replays saved ops.
+        await runtime.pendingStateManager.applyStashedOpsAt(runtimeSequenceNumber ?? 0);
+        // Initialize the base state of the runtime before it's returned.
+        await runtime.initializeBaseState();
+        return runtime;
+    }
+    get clientId() {
+        return this._getClientId();
+    }
+    get storage() {
+        return this._storage;
+    }
+    get flushMode() {
+        return this._flushMode;
+    }
+    get scope() {
+        return this.containerScope;
+    }
+    get IFluidDataStoreRegistry() {
+        return this.registry;
+    }
+    get attachState() {
+        return this._getAttachState();
+    }
+    get IFluidHandleContext() {
+        return this.handleContext;
+    }
+    /**
+     * 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--;
+        }
+    }
+    get connected() {
+        return this._connected;
+    }
+    /** clientId of parent (non-summarizing) container that owns summarizer container */
+    get summarizerClientId() {
+        return this.summarizerClientElection?.electedClientId;
+    }
+    get disposed() {
+        return this._disposed;
+    }
+    get summarizer() {
+        (0, core_utils_1.assert)(this._summarizer !== undefined, 0x257 /* "This is not summarizing container" */);
+        return this._summarizer;
+    }
+    isSummariesDisabled() {
+        return this.summaryConfiguration.state === "disabled";
+    }
+    isHeuristicsDisabled() {
+        return this.summaryConfiguration.state === "disableHeuristics";
+    }
+    getMaxOpsSinceLastSummary() {
+        return this.summaryConfiguration.state !== "disabled"
+            ? this.summaryConfiguration.maxOpsSinceLastSummary
+            : 0;
+    }
+    getInitialSummarizerDelayMs() {
+        // back-compat: initialSummarizerDelayMs was moved from ISummaryRuntimeOptions
+        //   to ISummaryConfiguration in 0.60.
+        if (this.runtimeOptions.summaryOptions.initialSummarizerDelayMs !== undefined) {
+            return this.runtimeOptions.summaryOptions.initialSummarizerDelayMs;
+        }
+        return this.summaryConfiguration.state !== "disabled"
+            ? this.summaryConfiguration.initialSummarizerDelayMs
+            : 0;
+    }
     /**
      * @internal
      */
-    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, idCompressor, requestHandler, summaryConfiguration = {
+    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, idCompressor, provideEntryPoint, requestHandler, summaryConfiguration = {
         // the defaults
         ...exports.DefaultSummaryConfiguration,
         // the runtime configuration overrides
         ...runtimeOptions.summaryOptions?.summaryConfigOverrides,
-    }, initializeEntryPoint) {
+    }) {
         super();
         this.registry = registry;
         this.runtimeOptions = runtimeOptions;
@@ -401,10 +603,10 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         if (baseSnapshot) {
             this.summarizerNode.updateBaseSummaryState(baseSnapshot);
         }
-        this.dataStores = new dataStores_1.DataStores((0, dataStores_1.getSummaryForDatastores)(baseSnapshot, metadata), this, (attachMsg) => this.submit({ type: ContainerMessageType.Attach, contents: attachMsg }), (id, createParam) => (summarizeInternal, getGCDataFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), (path) => this.garbageCollector.isNodeDeleted(path), new Map(dataStoreAliasMap));
+        this.dataStores = new dataStores_1.DataStores((0, dataStores_1.getSummaryForDatastores)(baseSnapshot, metadata), this, (attachMsg) => this.submit({ type: messageTypes_1.ContainerMessageType.Attach, contents: attachMsg }), (id, createParam) => (summarizeInternal, getGCDataFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), (path) => this.garbageCollector.isNodeDeleted(path), new Map(dataStoreAliasMap));
         this.blobManager = new blobManager_1.BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (localId, blobId) => {
             if (!this.disposed) {
-                this.submit({ type: ContainerMessageType.BlobAttach, contents: undefined }, undefined, {
+                this.submit({ type: messageTypes_1.ContainerMessageType.BlobAttach, contents: undefined }, undefined, {
                     localId,
                     blobId,
                 });
@@ -518,26 +720,6 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 this.summaryManager.start();
             }
         }
-        this.deltaManager.on("readonly", (readonly) => {
-            // we accumulate ops while being in read-only state.
-            // once user gets write permissions and we have active connection, flush all pending ops.
-            // Note that the inner (non-proxy) delta manager is needed here to get the readonly information.
-            (0, core_utils_1.assert)(readonly === this.innerDeltaManager.readOnlyInfo.readonly, 0x124 /* "inconsistent readonly property/event state" */);
-            // We need to be very careful with when we (re)send pending ops, to ensure that we only send ops
-            // when we either never send an op, or attempted to send it but we know for sure it was not
-            // sequenced by server and will never be sequenced (i.e. was lost)
-            // For loss of connection, we wait for our own "join" op and use it a a barrier to know all the
-            // ops that made it from previous connection, before switching clientId and raising "connected" event
-            // But with read-only permissions, if we transition between read-only and r/w states while on same
-            // connection, then we have no good signal to tell us when it's safe to send ops we accumulated while
-            // being in read-only state.
-            // For that reason, we support getting to read-only state only when disconnected. This ensures that we
-            // can rely on same safety mechanism and resend ops only when we establish new connection.
-            // This is applicable for read-only permissions (event is raised before connection is properly registered),
-            // but it's an extra requirement for Container.forceReadonly() API
-            (0, core_utils_1.assert)(!readonly || !this.connected, 0x125 /* "Unsafe to transition to read-only state!" */);
-            this.replayPendingStates();
-        });
         // logging hardware telemetry
         logger.sendTelemetryEvent({
             eventName: "DeviceSpec",
@@ -571,233 +753,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 (0, core_utils_1.assert)(this._summarizer !== undefined, 0x5bf /* Summarizer object is undefined in a summarizer client */);
                 return this._summarizer;
             }
-            return initializeEntryPoint?.(this);
-        });
-    }
-    /**
-     * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
-     */
-    get IFluidRouter() {
-        return this;
-    }
-    /**
-     * @deprecated - use loadRuntime instead.
-     * Load the stores from a snapshot and returns the runtime.
-     * @param context - Context of the container.
-     * @param registryEntries - Mapping to the stores.
-     * @param requestHandler - Request handlers for the container runtime
-     * @param runtimeOptions - Additional options to be passed to the runtime
-     * @param existing - (optional) When loading from an existing snapshot. Precedes context.existing if provided
-     * @param containerRuntimeCtor - (optional) Constructor to use to create the ContainerRuntime instance. This
-     * allows mixin classes to leverage this method to define their own async initializer.
-     */
-    static async load(context, registryEntries, requestHandler, runtimeOptions = {}, containerScope = context.scope, existing, containerRuntimeCtor = ContainerRuntime) {
-        let existingFlag = true;
-        if (!existing) {
-            existingFlag = false;
-        }
-        return this.loadRuntime({
-            context,
-            registryEntries,
-            existing: existingFlag,
-            requestHandler,
-            runtimeOptions,
-            containerScope,
-            containerRuntimeCtor,
-        });
-    }
-    /**
-     * Load the stores from a snapshot and returns the runtime.
-     * @param params - An object housing the runtime properties:
-     * - context - Context of the container.
-     * - registryEntries - Mapping from data store types to their corresponding factories.
-     * - existing - Pass 'true' if loading from an existing snapshot.
-     * - requestHandler - (optional) Request handler for the request() method of the container runtime.
-     * Only relevant for back-compat while we remove the request() method and move fully to entryPoint as the main pattern.
-     * - runtimeOptions - Additional options to be passed to the runtime
-     * - containerScope - runtime services provided with context
-     * - containerRuntimeCtor - Constructor to use to create the ContainerRuntime instance.
-     * This allows mixin classes to leverage this method to define their own async initializer.
-     * - initializeEntryPoint - Promise that resolves to an object which will act as entryPoint for the Container.
-     * This object should provide all the functionality that the Container is expected to provide to the loader layer.
-     */
-    static async loadRuntime(params) {
-        const { context, registryEntries, existing, requestHandler, runtimeOptions = {}, containerScope = {}, containerRuntimeCtor = ContainerRuntime, } = params;
-        const initializeEntryPoint = params.initializeEntryPoint ??
-            (async (containerRuntime) => ({
-                get IFluidRouter() {
-                    return this;
-                },
-                async request(req) {
-                    return containerRuntime.request(req);
-                },
-            }));
-        // If taggedLogger exists, use it. Otherwise, wrap the vanilla logger:
-        // back-compat: Remove the TaggedLoggerAdapter fallback once all the host are using loader > 0.45
-        const backCompatContext = context;
-        const passLogger = backCompatContext.taggedLogger ??
-            // eslint-disable-next-line import/no-deprecated
-            new telemetry_utils_1.TaggedLoggerAdapter(backCompatContext.logger);
-        const logger = (0, telemetry_utils_1.createChildLogger)({
-            logger: passLogger,
-            properties: {
-                all: {
-                    runtimeVersion: packageVersion_1.pkgVersion,
-                },
-            },
-        });
-        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, compressionOptions = defaultCompressionConfig, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, enableRuntimeIdCompressor = false, chunkSizeInBytes = defaultChunkSizeInBytes, enableOpReentryCheck = false, enableGroupedBatching = false, } = runtimeOptions;
-        const registry = new dataStoreRegistry_1.FluidDataStoreRegistry(registryEntries);
-        const tryFetchBlob = async (blobName) => {
-            const blobId = context.baseSnapshot?.blobs[blobName];
-            if (context.baseSnapshot && blobId) {
-                // IContainerContext storage api return type still has undefined in 0.39 package version.
-                // So once we release 0.40 container-defn package we can remove this check.
-                (0, core_utils_1.assert)(context.storage !== undefined, 0x1f5 /* "Attached state should have storage" */);
-                return (0, driver_utils_1.readAndParse)(context.storage, blobId);
-            }
-        };
-        const [chunks, metadata, electedSummarizerData, aliases, serializedIdCompressor] = await Promise.all([
-            tryFetchBlob(summary_1.chunksBlobName),
-            tryFetchBlob(summary_1.metadataBlobName),
-            tryFetchBlob(summary_1.electedSummarizerBlobName),
-            tryFetchBlob(summary_1.aliasBlobName),
-            tryFetchBlob(summary_1.idCompressorBlobName),
-        ]);
-        // read snapshot blobs needed for BlobManager to load
-        const blobManagerSnapshot = await blobManager_1.BlobManager.load(context.baseSnapshot?.trees[summary_1.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);
+            return provideEntryPoint(this);
         });
-        // Verify summary runtime sequence number matches protocol sequence number.
-        const runtimeSequenceNumber = metadata?.message?.sequenceNumber;
-        // When we load with pending state, we reuse an old snapshot so we don't expect these numbers to match
-        if (!context.pendingLocalState && runtimeSequenceNumber !== undefined) {
-            const protocolSequenceNumber = context.deltaManager.initialSequenceNumber;
-            // Unless bypass is explicitly set, then take action when sequence numbers mismatch.
-            if (loadSequenceNumberVerification !== "bypass" &&
-                runtimeSequenceNumber !== protocolSequenceNumber) {
-                // "Load from summary, runtime metadata sequenceNumber !== initialSequenceNumber"
-                const error = new telemetry_utils_1.DataCorruptionError(
-                // pre-0.58 error message: SummaryMetadataMismatch
-                "Summary metadata mismatch", { runtimeVersion: packageVersion_1.pkgVersion, runtimeSequenceNumber, protocolSequenceNumber });
-                if (loadSequenceNumberVerification === "log") {
-                    logger.sendErrorEvent({ eventName: "SequenceNumberMismatch" }, error);
-                }
-                else {
-                    context.closeFn(error);
-                }
-            }
-        }
-        const idCompressorEnabled = metadata?.idCompressorEnabled ?? runtimeOptions.enableRuntimeIdCompressor ?? false;
-        let idCompressor;
-        if (idCompressorEnabled) {
-            const { IdCompressor, createSessionId } = await Promise.resolve().then(() => __importStar(require("./id-compressor")));
-            idCompressor =
-                serializedIdCompressor !== undefined
-                    ? IdCompressor.deserialize(serializedIdCompressor, createSessionId())
-                    : IdCompressor.create(logger);
-        }
-        const runtime = new containerRuntimeCtor(context, registry, metadata, electedSummarizerData, chunks ?? [], aliases ?? [], {
-            summaryOptions,
-            gcOptions,
-            loadSequenceNumberVerification,
-            flushMode,
-            compressionOptions,
-            maxBatchSizeInBytes,
-            chunkSizeInBytes,
-            enableRuntimeIdCompressor,
-            enableOpReentryCheck,
-            enableGroupedBatching,
-        }, containerScope, logger, existing, blobManagerSnapshot, context.storage, idCompressor, requestHandler, undefined, // summaryConfiguration
-        initializeEntryPoint);
-        await runtime.blobManager.processStashedChanges();
-        // It's possible to have ops with a reference sequence number of 0. Op sequence numbers start
-        // at 1, so we won't see a replayed saved op with a sequence number of 0.
-        await runtime.pendingStateManager.applyStashedOpsAt(0);
-        // Initialize the base state of the runtime before it's returned.
-        await runtime.initializeBaseState();
-        return runtime;
-    }
-    get clientId() {
-        return this._getClientId();
-    }
-    get storage() {
-        return this._storage;
-    }
-    /** @deprecated - The functionality is no longer exposed publicly */
-    get reSubmitFn() {
-        return (type, contents, localOpMetadata, opMetadata) => this.reSubmitCore({ type, contents }, localOpMetadata, opMetadata);
-        // Note: compatDetails is not included in this deprecated API
-    }
-    get flushMode() {
-        return this._flushMode;
-    }
-    get scope() {
-        return this.containerScope;
-    }
-    get IFluidDataStoreRegistry() {
-        return this.registry;
-    }
-    get attachState() {
-        return this._getAttachState();
-    }
-    get IFluidHandleContext() {
-        return this.handleContext;
-    }
-    /**
-     * 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--;
-        }
-    }
-    get connected() {
-        return this._connected;
-    }
-    /** clientId of parent (non-summarizing) container that owns summarizer container */
-    get summarizerClientId() {
-        return this.summarizerClientElection?.electedClientId;
-    }
-    get disposed() {
-        return this._disposed;
-    }
-    get summarizer() {
-        (0, core_utils_1.assert)(this._summarizer !== undefined, 0x257 /* "This is not summarizing container" */);
-        return this._summarizer;
-    }
-    isSummariesDisabled() {
-        return this.summaryConfiguration.state === "disabled";
-    }
-    isHeuristicsDisabled() {
-        return this.summaryConfiguration.state === "disableHeuristics";
-    }
-    getMaxOpsSinceLastSummary() {
-        return this.summaryConfiguration.state !== "disabled"
-            ? this.summaryConfiguration.maxOpsSinceLastSummary
-            : 0;
-    }
-    getInitialSummarizerDelayMs() {
-        // back-compat: initialSummarizerDelayMs was moved from ISummaryRuntimeOptions
-        //   to ISummaryConfiguration in 0.60.
-        if (this.runtimeOptions.summaryOptions.initialSummarizerDelayMs !== undefined) {
-            return this.runtimeOptions.summaryOptions.initialSummarizerDelayMs;
-        }
-        return this.summaryConfiguration.state !== "disabled"
-            ? this.summaryConfiguration.initialSummarizerDelayMs
-            : 0;
     }
     /**
      * Initializes the state from the base snapshot this container runtime loaded from.
@@ -999,7 +956,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // in their own batches before the originating batch is sent.
         // Therefore, receiving them while attempting to send the originating batch
         // does not mean that the container is making any progress.
-        if (message?.type !== ContainerMessageType.ChunkedOp) {
+        if (message?.type !== messageTypes_1.ContainerMessageType.ChunkedOp) {
             this.consecutiveReconnects = 0;
         }
     }
@@ -1047,39 +1004,40 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      * Parse an op's type and actual content from given serialized content
      * ! Note: this format needs to be in-line with what is set in the "ContainerRuntime.submit(...)" method
      */
-    parseOpContent(serializedContent) {
-        (0, core_utils_1.assert)(serializedContent !== undefined, 0x6d5 /* content must be defined */);
-        const { type, contents, compatDetails } = JSON.parse(serializedContent);
-        (0, core_utils_1.assert)(type !== undefined, 0x6d6 /* incorrect op content format */);
-        return { type, contents, compatDetails };
-    }
-    async applyStashedOp(op) {
+    // TODO: markfields: confirm Local- versus Outbound- ContainerRuntimeMessage typing
+    parseLocalOpContent(serializedContents) {
+        (0, core_utils_1.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 */);
+        return message;
+    }
+    async applyStashedOp(serializedOpContent) {
         // Need to parse from string for back-compat
-        const { type, contents, compatDetails } = this.parseOpContent(op);
-        switch (type) {
-            case ContainerMessageType.FluidDataStoreOp:
-                return this.dataStores.applyStashedOp(contents);
-            case ContainerMessageType.Attach:
-                return this.dataStores.applyStashedAttachOp(contents);
-            case ContainerMessageType.IdAllocation:
+        const opContents = this.parseLocalOpContent(serializedOpContent);
+        switch (opContents.type) {
+            case messageTypes_1.ContainerMessageType.FluidDataStoreOp:
+                return this.dataStores.applyStashedOp(opContents.contents);
+            case messageTypes_1.ContainerMessageType.Attach:
+                return this.dataStores.applyStashedAttachOp(opContents.contents);
+            case messageTypes_1.ContainerMessageType.IdAllocation:
                 (0, core_utils_1.assert)(this.idCompressor !== undefined, 0x67b /* IdCompressor should be defined if enabled */);
-                return this.applyStashedIdAllocationOp(contents);
-            case ContainerMessageType.Alias:
-            case ContainerMessageType.BlobAttach:
+                return this.applyStashedIdAllocationOp(opContents.contents);
+            case messageTypes_1.ContainerMessageType.Alias:
+            case messageTypes_1.ContainerMessageType.BlobAttach:
                 return;
-            case ContainerMessageType.ChunkedOp:
+            case messageTypes_1.ContainerMessageType.ChunkedOp:
                 throw new Error("chunkedOp not expected here");
-            case ContainerMessageType.Rejoin:
+            case messageTypes_1.ContainerMessageType.Rejoin:
                 throw new Error("rejoin not expected here");
             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 = compatDetails?.behavior;
-                if (!compatBehaviorAllowsMessageType(type, compatBehavior)) {
+                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 */, {
                         messageDetails: JSON.stringify({
-                            type,
+                            type: opContents.type,
                             compatBehavior,
                         }),
                     });
@@ -1098,6 +1056,23 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             // Don't propagate "disconnected" event because we didn't propagate the previous "connected" event
             return;
         }
+        // If there are stashed blobs in the pending state, we need to delay
+        // propagation of the "connected" event until we have uploaded them to
+        // ensure we don't submit ops referencing a blob that has not been uploaded
+        const connecting = connected && !this._connected;
+        if (connecting && this.blobManager.hasPendingStashedBlobs()) {
+            (0, core_utils_1.assert)(!this.delayConnectClientId, 0x791 /* Connect event delay must be canceled before subsequent connect event */);
+            (0, core_utils_1.assert)(!!clientId, 0x792 /* Must have clientId when connecting */);
+            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) {
@@ -1150,18 +1125,33 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // or something different, like a system message.
         const modernRuntimeMessage = messageArg.type === protocol_definitions_1.MessageType.Operation;
         // Do shallow copy of message, as the processing flow will modify it.
+        // There might be multiple container instances receiving the same message.
+        // We do not need to make a deep copy. Each layer will just replace message.contents itself,
+        // but will not modify the contents object (likely it will replace it on the message).
         const messageCopy = { ...messageArg };
         for (const message of this.remoteMessageProcessor.process(messageCopy)) {
-            this.processCore(message, local, modernRuntimeMessage);
+            if (modernRuntimeMessage) {
+                this.processCore({
+                    // Cast it since we expect it to be this based on modernRuntimeMessage computation above.
+                    // There is nothing really ensuring that anytime original message.type is Operation that
+                    // the result messages will be so. In the end modern bool being true only directs to
+                    // throw error if ultimately unrecognized without compat details saying otherwise.
+                    message: message,
+                    local,
+                    modernRuntimeMessage,
+                });
+            }
+            else {
+                // Unrecognized message will be ignored.
+                this.processCore({ message, local, modernRuntimeMessage });
+            }
         }
     }
     /**
      * Direct the message to the correct subsystem for processing, and implement other side effects
-     * @param message - The unpacked message. Likely a ContainerRuntimeMessage, but could also be a system op
-     * @param local - Did this client send the op?
-     * @param modernRuntimeMessage - Does this appear like a current ContainerRuntimeMessage?
      */
-    processCore(message, local, modernRuntimeMessage) {
+    processCore(messageWithContext) {
+        const { message, local } = messageWithContext;
         // Surround the actual processing of the operation with messages to the schedule manager indicating
         // the beginning and end. This allows it to emit appropriate events and/or pause the processing of new
         // messages once a batch has been fully processed.
@@ -1169,16 +1159,18 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         this._processedClientSequenceNumber = message.clientSequenceNumber;
         try {
             let localOpMetadata;
-            if (local && modernRuntimeMessage && message.type !== ContainerMessageType.ChunkedOp) {
-                localOpMetadata = this.pendingStateManager.processPendingLocalMessage(message);
+            if (local &&
+                messageWithContext.modernRuntimeMessage &&
+                message.type !== messageTypes_1.ContainerMessageType.ChunkedOp) {
+                localOpMetadata = this.pendingStateManager.processPendingLocalMessage(messageWithContext.message);
             }
             // If there are no more pending messages after processing a local message,
             // the document is no longer dirty.
             if (!this.hasPendingMessages()) {
                 this.updateDocumentDirtyState(false);
             }
-            this.validateAndProcessRuntimeMessage(message, localOpMetadata, local, modernRuntimeMessage);
-            this.emit("op", message, modernRuntimeMessage);
+            this.validateAndProcessRuntimeMessage(messageWithContext, localOpMetadata);
+            this.emit("op", message, messageWithContext.modernRuntimeMessage);
             this.scheduleManager.afterOpProcessing(undefined, message);
             if (local) {
                 // If we have processed a local op, this means that the container is
@@ -1193,41 +1185,42 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         }
     }
     /**
-     * Assuming the given message is also a ContainerRuntimeMessage,
+     * Assuming the given message is also a TypedContainerRuntimeMessage,
      * checks its type and dispatches the message to the appropriate handler in the runtime.
-     * Throws a DataProcessingError if the message doesn't conform to the ContainerRuntimeMessage type.
+     * Throws a DataProcessingError if the message looks like but doesn't conform to a known TypedContainerRuntimeMessage type.
      */
-    validateAndProcessRuntimeMessage(message, localOpMetadata, local, expectRuntimeMessageType) {
-        // Optimistically extract ContainerRuntimeMessage-specific props from the message
-        const { type: maybeContainerMessageType, compatDetails } = message;
-        switch (maybeContainerMessageType) {
-            case ContainerMessageType.Attach:
-                this.dataStores.processAttachMessage(message, local);
+    validateAndProcessRuntimeMessage(messageWithContext, localOpMetadata) {
+        // TODO: destructure message and modernRuntimeMessage once using typescript 5.2.2+
+        const { local } = messageWithContext;
+        switch (messageWithContext.message.type) {
+            case messageTypes_1.ContainerMessageType.Attach:
+                this.dataStores.processAttachMessage(messageWithContext.message, local);
                 break;
-            case ContainerMessageType.Alias:
-                this.dataStores.processAliasMessage(message, localOpMetadata, local);
+            case messageTypes_1.ContainerMessageType.Alias:
+                this.dataStores.processAliasMessage(messageWithContext.message, localOpMetadata, local);
                 break;
-            case ContainerMessageType.FluidDataStoreOp:
-                this.dataStores.processFluidDataStoreOp(message, local, localOpMetadata);
+            case messageTypes_1.ContainerMessageType.FluidDataStoreOp:
+                this.dataStores.processFluidDataStoreOp(messageWithContext.message, local, localOpMetadata);
                 break;
-            case ContainerMessageType.BlobAttach:
-                this.blobManager.processBlobAttachOp(message, local);
+            case messageTypes_1.ContainerMessageType.BlobAttach:
+                this.blobManager.processBlobAttachOp(messageWithContext.message, local);
                 break;
-            case ContainerMessageType.IdAllocation:
+            case messageTypes_1.ContainerMessageType.IdAllocation:
                 (0, core_utils_1.assert)(this.idCompressor !== undefined, 0x67c /* IdCompressor should be defined if enabled */);
-                this.idCompressor.finalizeCreationRange(message.contents);
+                this.idCompressor.finalizeCreationRange(messageWithContext.message.contents);
                 break;
-            case ContainerMessageType.ChunkedOp:
-            case ContainerMessageType.Rejoin:
+            case messageTypes_1.ContainerMessageType.ChunkedOp:
+            case messageTypes_1.ContainerMessageType.Rejoin:
                 break;
             default: {
                 // If we didn't necessarily expect a runtime message type, then no worries - just return
                 // e.g. this case applies to system ops, or legacy ops that would have fallen into the above cases anyway.
-                if (!expectRuntimeMessageType) {
+                if (!messageWithContext.modernRuntimeMessage) {
                     return;
                 }
-                const compatBehavior = compatDetails?.behavior;
-                if (!compatBehaviorAllowsMessageType(maybeContainerMessageType, compatBehavior)) {
+                const compatBehavior = messageWithContext.message.compatDetails?.behavior;
+                if (!compatBehaviorAllowsMessageType(messageWithContext.message.type, compatBehavior)) {
+                    const { message } = messageWithContext;
                     const error = telemetry_utils_1.DataProcessingError.create(
                     // Former assert 0x3ce
                     "Runtime message of unknown type", "OpProcessing", message, {
@@ -1305,6 +1298,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      * @param wait - True if you want to wait for it.
      * @deprecated - Use getAliasedDataStoreEntryPoint instead to get an aliased data store's entry point.
      */
+    // eslint-disable-next-line import/no-deprecated
     async getRootDataStore(id, wait = true) {
         return this.getRootDataStoreChannel(id, wait);
     }
@@ -1369,8 +1363,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     /**
      * Returns the aliased data store's entryPoint, given the alias.
      * @param alias - The alias for the data store.
-     * @returns - The data store's entry point (IFluidHandle) if it exists and is aliased. Returns undefined if no
-     * data store has been assigned the given alias.
+     * @returns The data store's entry point ({@link @fluidframework/core-interfaces#IFluidHandle}) if it exists and is aliased.
+     * Returns undefined if no data store has been assigned the given alias.
      */
     async getAliasedDataStoreEntryPoint(alias) {
         await this.dataStores.waitIfPendingAlias(alias);
@@ -1437,13 +1431,13 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     isContainerMessageDirtyable({ type, contents }) {
         // For legacy purposes, exclude the old built-in AgentScheduler from dirty consideration as a special-case.
         // Ultimately we should have no special-cases from the ContainerRuntime's perspective.
-        if (type === ContainerMessageType.Attach) {
+        if (type === messageTypes_1.ContainerMessageType.Attach) {
             const attachMessage = contents;
             if (attachMessage.id === exports.agentSchedulerId) {
                 return false;
             }
         }
-        else if (type === ContainerMessageType.FluidDataStoreOp) {
+        else if (type === messageTypes_1.ContainerMessageType.FluidDataStoreOp) {
             const envelope = contents;
             if (envelope.address === exports.agentSchedulerId) {
                 return false;
@@ -1609,7 +1603,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     /**
      * After GC has run and identified nodes that are sweep ready, this is called to delete the sweep ready nodes.
      * @param sweepReadyRoutes - The routes of nodes that are sweep ready and should be deleted.
-     * @returns - The routes of nodes that were deleted.
+     * @returns The routes of nodes that were deleted.
      */
     deleteSweepReadyNodes(sweepReadyRoutes) {
         const { dataStoreRoutes, blobManagerRoutes } = this.getDataStoreAndBlobManagerRoutes(sweepReadyRoutes);
@@ -1671,7 +1665,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     /**
      * From a given list of routes, separate and return routes that belong to blob manager and data stores.
      * @param routes - A list of routes that can belong to data stores or blob manager.
-     * @returns - Two route lists - One that contains routes for blob manager and another one that contains routes
+     * @returns Two route lists - One that contains routes for blob manager and another one that contains routes
      * for data stores.
      */
     getDataStoreAndBlobManagerRoutes(routes) {
@@ -1723,16 +1717,13 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             },
         });
         (0, core_utils_1.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
         let latestSnapshotVersionId;
-        if (refreshLatestAck) {
-            const latestSnapshotInfo = await this.refreshLatestSummaryAckFromServer((0, telemetry_utils_1.createChildLogger)({
+        if (refreshLatestAck === true) {
+            return this.prefetchLatestSummaryThenClose((0, telemetry_utils_1.createChildLogger)({
                 logger: summaryNumberLogger,
                 properties: { all: { safeSummary: true } },
             }));
-            const latestSnapshotRefSeq = latestSnapshotInfo.latestSnapshotRefSeq;
-            latestSnapshotVersionId = latestSnapshotInfo.latestSnapshotVersionId;
-            // We might need to catch up to the latest summary's reference sequence number before pausing.
-            await this.waitForDeltaManagerToCatchup(latestSnapshotRefSeq, summaryNumberLogger);
         }
         // If there are pending (unacked ops), the summary will not be eventual consistent and it may even be
         // incorrect. So, wait for the container to be saved with a timeout. If the container is not saved
@@ -2052,21 +2043,21 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             address: id,
             contents,
         };
-        this.submit({ type: ContainerMessageType.FluidDataStoreOp, contents: envelope }, localOpMetadata);
+        this.submit({ type: messageTypes_1.ContainerMessageType.FluidDataStoreOp, contents: envelope }, localOpMetadata);
     }
     submitDataStoreAliasOp(contents, localOpMetadata) {
         const aliasMessage = contents;
         if (!(0, dataStore_1.isDataStoreAliasMessage)(aliasMessage)) {
             throw new telemetry_utils_1.UsageError("malformedDataStoreAliasMessage");
         }
-        this.submit({ type: ContainerMessageType.Alias, contents }, localOpMetadata);
+        this.submit({ type: messageTypes_1.ContainerMessageType.Alias, contents }, localOpMetadata);
     }
     async uploadBlob(blob, signal) {
         this.verifyNotClosed();
         return this.blobManager.createBlob(blob, signal);
     }
     maybeSubmitIdAllocationOp(type) {
-        if (type !== ContainerMessageType.IdAllocation) {
+        if (type !== messageTypes_1.ContainerMessageType.IdAllocation) {
             let idAllocationBatchMessage;
             let idRange;
             if (this.idCompressorEnabled) {
@@ -2077,7 +2068,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             }
             if (idRange !== undefined) {
                 const idAllocationMessage = {
-                    type: ContainerMessageType.IdAllocation,
+                    type: messageTypes_1.ContainerMessageType.IdAllocation,
                     contents: idRange,
                 };
                 idAllocationBatchMessage = {
@@ -2085,7 +2076,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                     referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
                     metadata: undefined,
                     localOpMetadata: this.idCompressor?.serialize(true),
-                    type: ContainerMessageType.IdAllocation,
+                    type: messageTypes_1.ContainerMessageType.IdAllocation,
                 };
             }
             if (idAllocationBatchMessage !== undefined) {
@@ -2142,11 +2133,11 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             // Please note that this does not change file format, so it can be disabled in the future if this
             // optimization no longer makes sense (for example, batch compression may make it less appealing).
             if (this.currentlyBatching() &&
-                type === ContainerMessageType.Attach &&
+                type === messageTypes_1.ContainerMessageType.Attach &&
                 this.disableAttachReorder !== true) {
                 this.outbox.submitAttach(message);
             }
-            else if (type === ContainerMessageType.BlobAttach) {
+            else if (type === messageTypes_1.ContainerMessageType.BlobAttach) {
                 // BlobAttach ops must have their metadata visible and cannot be grouped (see opGroupingManager.ts)
                 this.outbox.submitBlobAttach(message);
             }
@@ -2256,40 +2247,37 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     }
     reSubmit(message) {
         // Need to parse from string for back-compat
-        const containerRuntimeMessage = this.parseOpContent(message.content);
+        const containerRuntimeMessage = this.parseLocalOpContent(message.content);
         this.reSubmitCore(containerRuntimeMessage, message.localOpMetadata, message.opMetadata);
     }
     /**
      * Finds the right store and asks it to resubmit the message. This typically happens when we
      * reconnect and there are pending messages.
-     * @param message - The original ContainerRuntimeMessage.
+     * @param message - The original LocalContainerRuntimeMessage.
      * @param localOpMetadata - The local metadata associated with the original message.
      */
     reSubmitCore(message, localOpMetadata, opMetadata) {
-        const contents = message.contents;
         switch (message.type) {
-            case ContainerMessageType.FluidDataStoreOp:
+            case messageTypes_1.ContainerMessageType.FluidDataStoreOp:
                 // For Operations, call resubmitDataStoreOp which will find the right store
                 // and trigger resubmission on it.
-                this.dataStores.resubmitDataStoreOp(contents, localOpMetadata);
+                this.dataStores.resubmitDataStoreOp(message.contents, localOpMetadata);
                 break;
-            case ContainerMessageType.Attach:
-            case ContainerMessageType.Alias:
+            case messageTypes_1.ContainerMessageType.Attach:
+            case messageTypes_1.ContainerMessageType.Alias:
                 this.submit(message, localOpMetadata);
                 break;
-            case ContainerMessageType.IdAllocation:
-                // Remove the stashedState from the op if it's a stashed op
-                if (contents.stashedState !== undefined) {
-                    delete contents.stashedState;
-                }
+            case messageTypes_1.ContainerMessageType.IdAllocation: {
+                prepareLocalContainerRuntimeIdAllocationMessageForTransit(message);
                 this.submit(message, localOpMetadata);
                 break;
-            case ContainerMessageType.ChunkedOp:
+            }
+            case messageTypes_1.ContainerMessageType.ChunkedOp:
                 throw new Error(`chunkedOp not expected here`);
-            case ContainerMessageType.BlobAttach:
+            case messageTypes_1.ContainerMessageType.BlobAttach:
                 this.blobManager.reSubmit(opMetadata);
                 break;
-            case ContainerMessageType.Rejoin:
+            case messageTypes_1.ContainerMessageType.Rejoin:
                 this.submit(message);
                 break;
             default: {
@@ -2317,9 +2305,9 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     }
     rollback(content, localOpMetadata) {
         // Need to parse from string for back-compat
-        const { type, contents } = this.parseOpContent(content);
+        const { type, contents } = this.parseLocalOpContent(content);
         switch (type) {
-            case ContainerMessageType.FluidDataStoreOp:
+            case messageTypes_1.ContainerMessageType.FluidDataStoreOp:
                 // For operations, call rollbackDataStoreOp which will find the right store
                 // and trigger rollback on it.
                 this.dataStores.rollbackDataStoreOp(contents, localOpMetadata);
@@ -2329,17 +2317,6 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 throw new Error(`Can't rollback ${type}`);
         }
     }
-    async waitForDeltaManagerToCatchup(latestSnapshotRefSeq, summaryLogger) {
-        if (latestSnapshotRefSeq > this.deltaManager.lastSequenceNumber) {
-            // We need to catch up to the latest summary's reference sequence number before proceeding.
-            await telemetry_utils_1.PerformanceEvent.timedExecAsync(summaryLogger, {
-                eventName: "WaitingForSeq",
-                lastSequenceNumber: this.deltaManager.lastSequenceNumber,
-                targetSequenceNumber: latestSnapshotRefSeq,
-                lastKnownSeqNumber: this.deltaManager.lastKnownSeqNumber,
-            }, async () => waitForSeq(this.deltaManager, latestSnapshotRefSeq), { start: true, end: true, cancel: "error" });
-        }
-    }
     /** Implementation of ISummarizerInternalsProvider.refreshLatestSummaryAck */
     async refreshLatestSummaryAck(options) {
         const { proposalHandle, ackHandle, summaryRefSeq, summaryLogger } = options;
@@ -2385,18 +2362,25 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         await this.garbageCollector.refreshLatestSummary(result);
     }
     /**
-     * Fetches the latest snapshot from storage and uses it to refresh SummarizerNode's
-     * internal state as it should be considered the latest summary ack.
+     * Fetches the latest snapshot from storage to refresh the cache as a performance optimization and closes the
+     * summarizer to reload from new state.
      * @param summaryLogger - logger to use when fetching snapshot from storage
-     * @returns downloaded snapshot's reference sequence number
+     * @returns a generic summarization error
      */
-    async refreshLatestSummaryAckFromServer(summaryLogger) {
+    async prefetchLatestSummaryThenClose(summaryLogger) {
         const readAndParseBlob = async (id) => (0, driver_utils_1.readAndParse)(this.storage, id);
-        const { versionId, latestSnapshotRefSeq } = await this.fetchSnapshotFromStorage(summaryLogger, {
+        // 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.fetchSnapshotFromStorage(summaryLogger, {
             eventName: "RefreshLatestSummaryFromServerFetch",
         }, readAndParseBlob, null);
         await this.closeStaleSummarizer("RefreshLatestSummaryFromServerFetch");
-        return { latestSnapshotRefSeq, latestSnapshotVersionId: versionId };
+        return {
+            stage: "base",
+            error: "summary state stale - Unsupported option 'refreshLatestAck'",
+            referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
+            minimumSequenceNumber: this.deltaManager.minimumSequenceNumber,
+        };
     }
     async closeStaleSummarizer(codePath) {
         this.mc.logger.sendTelemetryEvent({
@@ -2419,7 +2403,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(logger, event, async (perfEvent) => {
             const stats = {};
             const trace = client_utils_1.Trace.start();
-            const versions = await this.storage.getVersions(versionId, 1, "refreshLatestSummaryAckFromServer", versionId === null ? driver_definitions_1.FetchSource.noCache : undefined);
+            const versions = await this.storage.getVersions(versionId, 1, "prefetchLatestSummaryBeforeClose", versionId === null ? driver_definitions_1.FetchSource.noCache : undefined);
             (0, core_utils_1.assert)(!!versions && !!versions[0], 0x137 /* "Failed to get version from storage" */);
             stats.getVersionDuration = trace.trace().duration;
             const maybeSnapshot = await this.storage.getSnapshotTree(versions[0]);
@@ -2447,15 +2431,17 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             if (this._orderSequentiallyCalls !== 0) {
                 throw new telemetry_utils_1.UsageError("can't get state during orderSequentially");
             }
-            const pendingAttachmentBlobs = await this.blobManager.getPendingBlobs(waitBlobsToAttach);
-            const pending = this.pendingStateManager.getLocalState();
-            if (!pendingAttachmentBlobs && !this.hasPendingMessages()) {
-                return; // no pending state to save
-            }
             // Flush pending batch.
             // getPendingLocalState() is only exposed through Container.closeAndGetPendingLocalState(), so it's safe
             // to close current batch.
             this.flush();
+            const pendingAttachmentBlobs = waitBlobsToAttach
+                ? await this.blobManager.attachAndGetPendingBlobs()
+                : undefined;
+            const pending = this.pendingStateManager.getLocalState();
+            if (!pendingAttachmentBlobs && !this.hasPendingMessages()) {
+                return; // no pending state to save
+            }
             const pendingState = {
                 pending,
                 pendingAttachmentBlobs,
@@ -2499,6 +2485,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
      * * Forms a function that will request a Summarizer.
      * @param loaderRouter - the loader acting as an IFluidRouter
      * */
+    // eslint-disable-next-line import/no-deprecated
     formRequestSummarizerFn(loaderRouter) {
         return async () => {
             const request = {
@@ -2513,6 +2500,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 },
                 url: "/_summarizer",
             };
+            // eslint-disable-next-line import/no-deprecated
             const fluidObject = await (0, runtime_utils_1.requestFluidObject)(loaderRouter, request);
             const summarizer = fluidObject.ISummarizer;
             if (!summarizer) {
@@ -2538,26 +2526,4 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     }
 }
 exports.ContainerRuntime = ContainerRuntime;
-/**
- * Wait for a specific sequence number. Promise should resolve when we reach that number,
- * or reject if closed.
- */
-const waitForSeq = async (deltaManager, targetSeq) => new Promise((resolve, reject) => {
-    // TODO: remove cast to any when actual event is determined
-    deltaManager.on("closed", reject);
-    deltaManager.on("disposed", reject);
-    // If we already reached target sequence number, simply resolve the promise.
-    if (deltaManager.lastSequenceNumber >= targetSeq) {
-        resolve();
-    }
-    else {
-        const handleOp = (message) => {
-            if (message.sequenceNumber >= targetSeq) {
-                resolve();
-                deltaManager.off("op", handleOp);
-            }
-        };
-        deltaManager.on("op", handleOp);
-    }
-});
 //# sourceMappingURL=containerRuntime.js.map