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

package/lib/containerRuntime.js

@@ -25,32 +25,12 @@ import { BindBatchTracker } from "./batchTracker";
 import { ScheduleManager } from "./scheduleManager";
 import { OpCompressor, OpDecompressor, Outbox, OpSplitter, RemoteMessageProcessor, OpGroupingManager, getLongStack, } from "./opLifecycle";
 import { DeltaManagerSummarizerProxy } from "./deltaManagerSummarizerProxy";
-export 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 || (ContainerMessageType = {}));
+import { ContainerMessageType, } from "./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
  */
@@ -58,6 +38,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;
+    }
+}
 export const DefaultSummaryConfiguration = {
     state: "enabled",
     minIdleTime: 0,
@@ -127,7 +113,7 @@ export const defaultPendingOpsRetryDelayMs = 1000;
  */
 const defaultCloseSummarizerDelayMs = 5000; // 5 seconds
 /**
- * @deprecated - use ContainerRuntimeMessage instead
+ * @deprecated - use ContainerRuntimeMessageType instead
  */
 export var RuntimeMessage;
 (function (RuntimeMessage) {
@@ -495,26 +481,6 @@ export class ContainerRuntime extends 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.
-            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
-            assert(!readonly || !this.connected, 0x125 /* "Unsafe to transition to read-only state!" */);
-            this.replayPendingStates();
-        });
         // logging hardware telemetry
         logger.sendTelemetryEvent({
             eventName: "DeviceSpec",
@@ -690,10 +656,9 @@ export class ContainerRuntime extends TypedEventEmitter {
             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);
+        // 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;
@@ -1024,23 +989,24 @@ export class ContainerRuntime extends 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) {
-        assert(serializedContent !== undefined, 0x6d5 /* content must be defined */);
-        const { type, contents, compatDetails } = JSON.parse(serializedContent);
-        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) {
+        assert(serializedContents !== undefined, 0x6d5 /* content must be defined */);
+        const message = JSON.parse(serializedContents);
+        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) {
+        const opContents = this.parseLocalOpContent(serializedOpContent);
+        switch (opContents.type) {
             case ContainerMessageType.FluidDataStoreOp:
-                return this.dataStores.applyStashedOp(contents);
+                return this.dataStores.applyStashedOp(opContents.contents);
             case ContainerMessageType.Attach:
-                return this.dataStores.applyStashedAttachOp(contents);
+                return this.dataStores.applyStashedAttachOp(opContents.contents);
             case ContainerMessageType.IdAllocation:
                 assert(this.idCompressor !== undefined, 0x67b /* IdCompressor should be defined if enabled */);
-                return this.applyStashedIdAllocationOp(contents);
+                return this.applyStashedIdAllocationOp(opContents.contents);
             case ContainerMessageType.Alias:
             case ContainerMessageType.BlobAttach:
                 return;
@@ -1052,11 +1018,11 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // 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 = DataProcessingError.create("Stashed runtime message of unknown type", "applyStashedOp", undefined /* sequencedMessage */, {
                         messageDetails: JSON.stringify({
-                            type,
+                            type: opContents.type,
                             compatBehavior,
                         }),
                     });
@@ -1075,6 +1041,23 @@ export class ContainerRuntime extends 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()) {
+            assert(!this.delayConnectClientId, 0x791 /* Connect event delay must be canceled before subsequent connect event */);
+            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) {
@@ -1127,18 +1110,33 @@ export class ContainerRuntime extends TypedEventEmitter {
         // or something different, like a system message.
         const modernRuntimeMessage = messageArg.type === 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.
@@ -1146,16 +1144,18 @@ export class ContainerRuntime extends 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 !== 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
@@ -1170,29 +1170,29 @@ export class ContainerRuntime extends 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) {
+    validateAndProcessRuntimeMessage(messageWithContext, localOpMetadata) {
+        // TODO: destructure message and modernRuntimeMessage once using typescript 5.2.2+
+        const { local } = messageWithContext;
+        switch (messageWithContext.message.type) {
             case ContainerMessageType.Attach:
-                this.dataStores.processAttachMessage(message, local);
+                this.dataStores.processAttachMessage(messageWithContext.message, local);
                 break;
             case ContainerMessageType.Alias:
-                this.dataStores.processAliasMessage(message, localOpMetadata, local);
+                this.dataStores.processAliasMessage(messageWithContext.message, localOpMetadata, local);
                 break;
             case ContainerMessageType.FluidDataStoreOp:
-                this.dataStores.processFluidDataStoreOp(message, local, localOpMetadata);
+                this.dataStores.processFluidDataStoreOp(messageWithContext.message, local, localOpMetadata);
                 break;
             case ContainerMessageType.BlobAttach:
-                this.blobManager.processBlobAttachOp(message, local);
+                this.blobManager.processBlobAttachOp(messageWithContext.message, local);
                 break;
             case ContainerMessageType.IdAllocation:
                 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:
@@ -1200,11 +1200,12 @@ export class ContainerRuntime extends TypedEventEmitter {
             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 = DataProcessingError.create(
                     // Former assert 0x3ce
                     "Runtime message of unknown type", "OpProcessing", message, {
@@ -1346,8 +1347,8 @@ export class ContainerRuntime extends 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);
@@ -1586,7 +1587,7 @@ export class ContainerRuntime extends 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);
@@ -1648,7 +1649,7 @@ export class ContainerRuntime extends 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) {
@@ -1700,16 +1701,13 @@ export class ContainerRuntime extends TypedEventEmitter {
             },
         });
         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(createChildLogger({
+        if (refreshLatestAck === true) {
+            return this.prefetchLatestSummaryThenClose(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
@@ -2233,34 +2231,31 @@ export class ContainerRuntime extends 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:
                 // 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:
                 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 ContainerMessageType.IdAllocation: {
+                prepareLocalContainerRuntimeIdAllocationMessageForTransit(message);
                 this.submit(message, localOpMetadata);
                 break;
+            }
             case ContainerMessageType.ChunkedOp:
                 throw new Error(`chunkedOp not expected here`);
             case ContainerMessageType.BlobAttach:
@@ -2294,7 +2289,7 @@ export class ContainerRuntime extends 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:
                 // For operations, call rollbackDataStoreOp which will find the right store
@@ -2306,17 +2301,6 @@ export class ContainerRuntime extends 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 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;
@@ -2362,18 +2346,25 @@ export class ContainerRuntime extends 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) => 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({
@@ -2396,7 +2387,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         return PerformanceEvent.timedExecAsync(logger, event, async (perfEvent) => {
             const stats = {};
             const trace = Trace.start();
-            const versions = await this.storage.getVersions(versionId, 1, "refreshLatestSummaryAckFromServer", versionId === null ? FetchSource.noCache : undefined);
+            const versions = await this.storage.getVersions(versionId, 1, "prefetchLatestSummaryBeforeClose", versionId === null ? FetchSource.noCache : undefined);
             assert(!!versions && !!versions[0], 0x137 /* "Failed to get version from storage" */);
             stats.getVersionDuration = trace.trace().duration;
             const maybeSnapshot = await this.storage.getSnapshotTree(versions[0]);
@@ -2424,15 +2415,17 @@ export class ContainerRuntime extends TypedEventEmitter {
             if (this._orderSequentiallyCalls !== 0) {
                 throw new 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,
@@ -2514,26 +2507,4 @@ export class ContainerRuntime extends TypedEventEmitter {
         return killSwitch !== true && this.runtimeOptions.enableGroupedBatching;
     }
 }
-/**
- * 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