@fluidframework/container-runtime 2.0.0-dev.1.4.5.105745 → 2.0.0-dev.2.2.0.111723

package/dist/containerRuntime.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContainerRuntime = exports.getDeviceSpec = exports.agentSchedulerId = exports.unpackRuntimeMessage = exports.isRuntimeMessage = exports.RuntimeMessage = exports.RuntimeHeaders = exports.DefaultSummaryConfiguration = exports.ContainerMessageType = void 0;
+exports.ContainerRuntime = exports.getDeviceSpec = exports.agentSchedulerId = exports.unpackRuntimeMessage = exports.isRuntimeMessage = exports.RuntimeMessage = exports.CompressionAlgorithms = exports.RuntimeHeaders = exports.DefaultSummaryConfiguration = exports.ContainerMessageType = void 0;
 const container_definitions_1 = require("@fluidframework/container-definitions");
 const common_utils_1 = require("@fluidframework/common-utils");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
@@ -33,6 +33,7 @@ const dataStore_1 = require("./dataStore");
 const batchTracker_1 = require("./batchTracker");
 const serializedSnapshotStorage_1 = require("./serializedSnapshotStorage");
 const scheduleManager_1 = require("./scheduleManager");
+const opDecompressor_1 = require("./opDecompressor");
 var ContainerMessageType;
 (function (ContainerMessageType) {
     // An op to be delivered to store
@@ -61,6 +62,7 @@ exports.DefaultSummaryConfiguration = {
     summarizerClientElection: false,
     nonRuntimeOpWeight: 0.1,
     runtimeOpWeight: 1.0,
+    nonRuntimeHeuristicThreshold: 20,
 };
 /**
  * Accepted header keys for requests coming to the runtime.
@@ -77,8 +79,20 @@ var RuntimeHeaders;
     /** True if the request is coming from an IFluidHandle. */
     RuntimeHeaders["viaHandle"] = "viaHandle";
 })(RuntimeHeaders = exports.RuntimeHeaders || (exports.RuntimeHeaders = {}));
+/**
+ * Available compression algorithms for op compression.
+ */
+var CompressionAlgorithms;
+(function (CompressionAlgorithms) {
+    CompressionAlgorithms["lz4"] = "lz4";
+})(CompressionAlgorithms = exports.CompressionAlgorithms || (exports.CompressionAlgorithms = {}));
 const maxConsecutiveReconnectsKey = "Fluid.ContainerRuntime.MaxConsecutiveReconnects";
 const defaultFlushMode = runtime_definitions_1.FlushMode.TurnBased;
+// The actual limit is 1Mb (socket.io and Kafka limits)
+// We can't estimate it fully, as we
+// - do not know what properties relay service will add
+// - we do not stringify final op, thus we do not know how much escaping will be added.
+const defaultMaxBatchSizeInBytes = 950 * 1024;
 /**
  * @deprecated - use ContainerRuntimeMessage instead
  */
@@ -96,16 +110,13 @@ var RuntimeMessage;
  * @deprecated - please use version in driver-utils
  */
 function isRuntimeMessage(message) {
-    if (Object.values(RuntimeMessage).includes(message.type)) {
-        return true;
-    }
-    return false;
+    return Object.values(RuntimeMessage).includes(message.type);
 }
 exports.isRuntimeMessage = isRuntimeMessage;
 /**
  * Unpacks runtime messages
  *
- * @remarks This API makes no promises regarding backward-compatability. This is internal API.
+ * @remarks This API makes no promises regarding backward-compatibility. This is internal API.
  * @param message - message (as it observed in storage / service)
  * @returns unpacked runtime message
  *
@@ -120,7 +131,6 @@ function unpackRuntimeMessage(message) {
         else {
             // new format
             const innerContents = message.contents;
-            (0, common_utils_1.assert)(innerContents.type !== undefined, 0x121 /* "Undefined inner contents type!" */);
             message.type = innerContents.type;
             message.contents = innerContents.contents;
         }
@@ -162,7 +172,7 @@ exports.getDeviceSpec = getDeviceSpec;
  */
 class ContainerRuntime extends common_utils_1.TypedEventEmitter {
     constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, requestHandler, summaryConfiguration) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f;
         if (summaryConfiguration === void 0) { summaryConfiguration = Object.assign(Object.assign({}, exports.DefaultSummaryConfiguration), (_a = runtimeOptions.summaryOptions) === null || _a === void 0 ? void 0 : _a.summaryConfigOverrides); }
         super();
         this.context = context;
@@ -173,9 +183,10 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         this._storage = _storage;
         this.requestHandler = requestHandler;
         this.summaryConfiguration = summaryConfiguration;
+        this.opDecompressor = new opDecompressor_1.OpDecompressor();
         this.defaultMaxConsecutiveReconnects = 7;
         this._orderSequentiallyCalls = 0;
-        this.flushTrigger = false;
+        this.flushMicroTaskExists = false;
         this.savedOps = [];
         this.consecutiveReconnects = 0;
         this._disposed = false;
@@ -187,12 +198,6 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             signalTimestamp: 0,
             trackingSignalSequenceNumber: undefined,
         };
-        // Provide lower soft limit - we want to have some number of ops to get efficiency in compression & bandwidth usage,
-        // but at the same time we want to send these ops sooner, to reduce overall latency of processing a batch.
-        // So there is some ballance here, that depends on compression algorithm and its efficiency working with smaller
-        // payloads. That number represents final (compressed) bits (once compression is implemented).
-        this.pendingAttachBatch = new batchManager_1.BatchManager(64 * 1024);
-        this.pendingBatch = new batchManager_1.BatchManager();
         this.summarizeOnDemand = (...args) => {
             if (this.clientDetails.type === summarizerClientElection_1.summarizerClientType) {
                 return this.summarizer.summarizeOnDemand(...args);
@@ -221,6 +226,26 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 throw new container_utils_1.UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
             }
         };
+        let loadSummaryNumber;
+        // Get the container creation metadata. For new container, we initialize these. For existing containers,
+        // get the values from the metadata blob.
+        if (existing) {
+            this.createContainerMetadata = {
+                createContainerRuntimeVersion: metadata === null || metadata === void 0 ? void 0 : metadata.createContainerRuntimeVersion,
+                createContainerTimestamp: metadata === null || metadata === void 0 ? void 0 : metadata.createContainerTimestamp,
+            };
+            // summaryNumber was renamed from summaryCount. For older docs that haven't been opened for a long time,
+            // the count is reset to 0.
+            loadSummaryNumber = (_b = metadata === null || metadata === void 0 ? void 0 : metadata.summaryNumber) !== null && _b !== void 0 ? _b : 0;
+        }
+        else {
+            this.createContainerMetadata = {
+                createContainerRuntimeVersion: packageVersion_1.pkgVersion,
+                createContainerTimestamp: Date.now(),
+            };
+            loadSummaryNumber = 0;
+        }
+        this.nextSummaryNumber = loadSummaryNumber + 1;
         this.messageAtLastSummary = metadata === null || metadata === void 0 ? void 0 : metadata.message;
         this._connected = this.context.connected;
         this.chunkMap = new Map(chunks);
@@ -235,10 +260,31 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         this.maxOpsSinceLastSummary = this.getMaxOpsSinceLastSummary();
         this.initialSummarizerDelayMs = this.getInitialSummarizerDelayMs();
         this.maxConsecutiveReconnects =
-            (_b = this.mc.config.getNumber(maxConsecutiveReconnectsKey)) !== null && _b !== void 0 ? _b : this.defaultMaxConsecutiveReconnects;
+            (_c = this.mc.config.getNumber(maxConsecutiveReconnectsKey)) !== null && _c !== void 0 ? _c : this.defaultMaxConsecutiveReconnects;
         this._flushMode = runtimeOptions.flushMode;
+        // Provide lower soft limit - we want to have some number of ops to get efficiency in compression
+        // & bandwidth usage, but at the same time we want to send these ops sooner, to reduce overall
+        // latency of processing a batch.
+        // So there is some ballance here, that depends on compression algorithm and its efficiency working with smaller
+        // payloads. That number represents final (compressed) bits (once compression is implemented).
+        this.pendingAttachBatch = new batchManager_1.BatchManager(this.mc.logger, {
+            hardLimit: runtimeOptions.maxBatchSizeInBytes,
+            softLimit: 64 * 1024,
+            compressionOptions: runtimeOptions.compressionOptions
+        });
+        this.pendingBatch = new batchManager_1.BatchManager(this.mc.logger, {
+            hardLimit: runtimeOptions.maxBatchSizeInBytes,
+            compressionOptions: runtimeOptions.compressionOptions
+        });
         const pendingRuntimeState = context.pendingLocalState;
-        const baseSnapshot = (_c = pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.baseSnapshot) !== null && _c !== void 0 ? _c : context.baseSnapshot;
+        const baseSnapshot = (_d = pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.baseSnapshot) !== null && _d !== void 0 ? _d : context.baseSnapshot;
+        const maxSnapshotCacheDurationMs = (_f = (_e = this._storage) === null || _e === void 0 ? void 0 : _e.policies) === null || _f === void 0 ? void 0 : _f.maximumCacheDurationMs;
+        if (maxSnapshotCacheDurationMs !== undefined && maxSnapshotCacheDurationMs > 5 * 24 * 60 * 60 * 1000) {
+            // This is a runtime enforcement of what's already explicit in the policy's type itself,
+            // which dictates the value is either undefined or exactly 5 days in ms.
+            // As long as the actual value is less than 5 days, the assumptions GC makes here are valid.
+            throw new container_utils_1.UsageError("Driver's maximumCacheDurationMs policy cannot exceed 5 days");
+        }
         this.garbageCollector = garbageCollection_1.GarbageCollector.create({
             runtime: this,
             gcOptions: this.runtimeOptions.gcOptions,
@@ -246,6 +292,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             baseLogger: this.mc.logger,
             existing,
             metadata,
+            createContainerMetadata: this.createContainerMetadata,
             isSummarizerClient: this.context.clientDetails.type === summarizerClientElection_1.summarizerClientType,
             getNodePackagePath: async (nodePath) => this.getGCNodePackagePath(nodePath),
             getLastSummaryTimestampMs: () => { var _a; return (_a = this.messageAtLastSummary) === null || _a === void 0 ? void 0 : _a.timestamp; },
@@ -271,9 +318,9 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             gcDisabled: !this.garbageCollector.shouldRunGC,
         });
         if (baseSnapshot) {
-            this.summarizerNode.loadBaseSummaryWithoutDifferential(baseSnapshot);
+            this.summarizerNode.updateBaseSummaryState(baseSnapshot);
         }
-        this.dataStores = new dataStores_1.DataStores((0, dataStores_1.getSummaryForDatastores)(baseSnapshot, metadata), this, (attachMsg) => this.submit(ContainerMessageType.Attach, attachMsg), (id, createParam) => (summarizeInternal, getGCDataFn, getBaseGCDetailsFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn, getBaseGCDetailsFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, async () => this.garbageCollector.getBaseGCDetails(), (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), new Map(dataStoreAliasMap), this.garbageCollector.writeDataAtRoot);
+        this.dataStores = new dataStores_1.DataStores((0, dataStores_1.getSummaryForDatastores)(baseSnapshot, metadata), this, (attachMsg) => this.submit(ContainerMessageType.Attach, attachMsg), (id, createParam) => (summarizeInternal, getGCDataFn, getBaseGCDetailsFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn, getBaseGCDetailsFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, async () => this.garbageCollector.getBaseGCDetails(), (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), new Map(dataStoreAliasMap));
         this.blobManager = new blobManager_1.BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (blobId, localId) => {
             if (!this.disposed) {
                 this.submit(ContainerMessageType.BlobAttach, undefined, undefined, { blobId, localId });
@@ -287,10 +334,10 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             close: this.closeFn,
             connected: () => this.connected,
             flush: this.flush.bind(this),
-            flushMode: () => this.flushMode,
             reSubmit: this.reSubmit.bind(this),
-            setFlushMode: (mode) => this.setFlushMode(mode),
-        }, this._flushMode, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pending);
+            rollback: this.rollback.bind(this),
+            orderSequentially: this.orderSequentially.bind(this),
+        }, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pending);
         this.context.quorum.on("removeMember", (clientId) => {
             this.clearPartialChunks(clientId);
         });
@@ -314,7 +361,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 // if summaries are enabled and we are not the summarizer client.
                 const defaultAction = () => {
                     if (this.summaryCollection.opsSinceLastAck > this.maxOpsSinceLastSummary) {
-                        this.logger.sendErrorEvent({ eventName: "SummaryStatus:Behind" });
+                        this.logger.sendTelemetryEvent({ eventName: "SummaryStatus:Behind" });
                         // unregister default to no log on every op after falling behind
                         // and register summary ack handler to re-register this handler
                         // after successful summary
@@ -360,26 +407,6 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         });
         // logging hardware telemetry
         logger.sendTelemetryEvent(Object.assign({ eventName: "DeviceSpec" }, getDeviceSpec()));
-        let loadSummaryNumber;
-        // Get the container creation metadata. For new container, we initialize these. For existing containers,
-        // get the values from the metadata blob.
-        if (existing) {
-            this.createContainerMetadata = {
-                createContainerRuntimeVersion: metadata === null || metadata === void 0 ? void 0 : metadata.createContainerRuntimeVersion,
-                createContainerTimestamp: metadata === null || metadata === void 0 ? void 0 : metadata.createContainerTimestamp,
-            };
-            // summaryNumber was renamed from summaryCount. For older docs that haven't been opened for a long time,
-            // the count is reset to 0.
-            loadSummaryNumber = (_d = metadata === null || metadata === void 0 ? void 0 : metadata.summaryNumber) !== null && _d !== void 0 ? _d : 0;
-        }
-        else {
-            this.createContainerMetadata = {
-                createContainerRuntimeVersion: packageVersion_1.pkgVersion,
-                createContainerTimestamp: Date.now(),
-            };
-            loadSummaryNumber = 0;
-        }
-        this.nextSummaryNumber = loadSummaryNumber + 1;
         this.logger.sendTelemetryEvent(Object.assign(Object.assign(Object.assign({ eventName: "ContainerLoadStats" }, this.createContainerMetadata), this.dataStores.containerLoadStats), { summaryNumber: loadSummaryNumber, summaryFormatVersion: metadata === null || metadata === void 0 ? void 0 : metadata.summaryFormatVersion, disableIsolatedChannels: metadata === null || metadata === void 0 ? void 0 : metadata.disableIsolatedChannels, gcVersion: metadata === null || metadata === void 0 ? void 0 : metadata.gcFeature }));
         (0, connectionTelemetry_1.ReportOpPerfTelemetry)(this.context.clientId, this.deltaManager, this.logger);
         (0, batchTracker_1.BindBatchTracker)(this, this.logger);
@@ -405,7 +432,8 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 runtimeVersion: packageVersion_1.pkgVersion,
             },
         });
-        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, enableOfflineLoad = false, } = runtimeOptions;
+        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, enableOfflineLoad = false, compressionOptions = { minimumBatchSizeInBytes: Number.POSITIVE_INFINITY,
+            compressionAlgorithm: CompressionAlgorithms.lz4 }, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, } = runtimeOptions;
         const pendingRuntimeState = context.pendingLocalState;
         const baseSnapshot = (_b = pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.baseSnapshot) !== null && _b !== void 0 ? _b : context.baseSnapshot;
         const storage = !pendingRuntimeState ?
@@ -460,13 +488,16 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             loadSequenceNumberVerification,
             flushMode,
             enableOfflineLoad,
+            compressionOptions,
+            maxBatchSizeInBytes,
         }, containerScope, logger, loadExisting, blobManagerSnapshot, storage, requestHandler);
         if (pendingRuntimeState) {
             await runtime.processSavedOps(pendingRuntimeState);
             // delete these once runtime has seen them to save space
             pendingRuntimeState.savedOps = [];
         }
-        await runtime.getSnapshotBlobs();
+        // Initialize the base state of the runtime before it's returned.
+        await runtime.initializeBaseState();
         return runtime;
     }
     get options() {
@@ -573,6 +604,13 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             ? this.summaryConfiguration.initialSummarizerDelayMs
             : 0;
     }
+    /**
+     * Initializes the state from the base snapshot this container runtime loaded from.
+     */
+    async initializeBaseState() {
+        await this.initializeBaseSnapshotBlobs();
+        await this.garbageCollector.initializeBaseState();
+    }
     dispose(error) {
         var _a;
         if (this._disposed) {
@@ -671,13 +709,16 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         return (_a = this.dataStores.aliases.get(maybeAlias)) !== null && _a !== void 0 ? _a : maybeAlias;
     }
     async getDataStoreFromRequest(id, request) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         const wait = typeof ((_a = request.headers) === null || _a === void 0 ? void 0 : _a[RuntimeHeaders.wait]) === "boolean"
             ? (_b = request.headers) === null || _b === void 0 ? void 0 : _b[RuntimeHeaders.wait]
             : true;
+        const viaHandle = typeof ((_c = request.headers) === null || _c === void 0 ? void 0 : _c[RuntimeHeaders.viaHandle]) === "boolean"
+            ? (_d = request.headers) === null || _d === void 0 ? void 0 : _d[RuntimeHeaders.viaHandle]
+            : false;
         await this.dataStores.waitIfPendingAlias(id);
         const internalId = this.internalId(id);
-        const dataStoreContext = await this.dataStores.getDataStore(internalId, wait);
+        const dataStoreContext = await this.dataStores.getDataStore(internalId, wait, viaHandle);
         /**
          * If GC should run and this an external app request with "externalRequest" header, we need to return
          * an error if the data store being requested is marked as unreferenced as per the data store's base
@@ -686,7 +727,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
          * This is a workaround to handle scenarios where a data store shared with an external app is deleted
          * and marked as unreferenced by GC. Returning an error will fail to load the data store for the app.
          */
-        if (((_c = request.headers) === null || _c === void 0 ? void 0 : _c[RuntimeHeaders.externalRequest]) && this.garbageCollector.shouldRunGC) {
+        if (((_e = request.headers) === null || _e === void 0 ? void 0 : _e[RuntimeHeaders.externalRequest]) && this.garbageCollector.shouldRunGC) {
             // The data store is referenced if used routes in the base summary has a route to self.
             // Older documents may not have used routes in the summary. They are considered referenced.
             const usedRoutes = (await dataStoreContext.getBaseGCDetails()).usedRoutes;
@@ -733,11 +774,9 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         if (Object.keys(blobManagerSummary.summary.tree).length > 0) {
             (0, runtime_utils_1.addTreeToSummary)(summaryTree, summaryFormat_1.blobsTreeName, blobManagerSummary);
         }
-        if (this.garbageCollector.writeDataAtRoot) {
-            const gcSummary = this.garbageCollector.summarize(fullTree, trackState, telemetryContext);
-            if (gcSummary !== undefined) {
-                (0, runtime_utils_1.addSummarizeResultToSummary)(summaryTree, garbageCollection_1.gcTreeKey, gcSummary);
-            }
+        const gcSummary = this.garbageCollector.summarize(fullTree, trackState, telemetryContext);
+        if (gcSummary !== undefined) {
+            (0, runtime_utils_1.addSummarizeResultToSummary)(summaryTree, garbageCollection_1.gcTreeKey, gcSummary);
         }
     }
     // Track how many times the container tries to reconnect with pending messages.
@@ -893,6 +932,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         if (typeof message.contents === "string" && message.contents !== "") {
             message.contents = JSON.parse(message.contents);
         }
+        message = this.opDecompressor.processMessage(message);
         // Caveat: This will return false for runtime message in very old format, that are used in snapshot tests
         // This format was not shipped to production workflows.
         const runtimeMessage = unpackRuntimeMessage(message);
@@ -1010,27 +1050,14 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
     async getRootDataStoreChannel(id, wait = true) {
         await this.dataStores.waitIfPendingAlias(id);
         const internalId = this.internalId(id);
-        const context = await this.dataStores.getDataStore(internalId, wait);
+        const context = await this.dataStores.getDataStore(internalId, wait, false /* viaHandle */);
         (0, common_utils_1.assert)(await context.isRoot(), 0x12b /* "did not get root data store" */);
         return context.realize();
     }
-    setFlushMode(mode) {
-        if (mode === this._flushMode) {
-            return;
-        }
-        this.mc.logger.sendTelemetryEvent({
-            eventName: "FlushMode Updated",
-            old: this._flushMode,
-            new: mode,
-        });
-        // Flush any pending batches if switching to immediate
-        if (mode === runtime_definitions_1.FlushMode.Immediate) {
-            this.flush();
-        }
-        this._flushMode = mode;
-        // Let the PendingStateManager know that FlushMode has been updated.
-        this.pendingStateManager.onFlushModeUpdated(mode);
-    }
+    /**
+     * Flush the pending ops manually.
+     * This method is expected to be called at the end of a batch.
+     */
     flush() {
         (0, common_utils_1.assert)(this._orderSequentiallyCalls === 0, 0x24c /* "Cannot call `flush()` from `orderSequentially`'s callback" */);
         this.flushBatch(this.pendingAttachBatch.popBatch());
@@ -1038,6 +1065,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         (0, common_utils_1.assert)(this.emptyBatch, 0x3cf /* reentrancy */);
     }
     flushBatch(batch) {
+        var _a;
         const length = batch.length;
         if (length > 1) {
             batch[0].metadata = Object.assign(Object.assign({}, batch[0].metadata), { batch: true });
@@ -1068,6 +1096,10 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 // Legacy path - supporting old loader versions. Can be removed only when LTS moves above
                 // version that has support for batches (submitBatchFn)
                 for (const message of batch) {
+                    // Legacy path doesn't support compressed payloads and will submit uncompressed payload anyways
+                    if ((_a = message.metadata) === null || _a === void 0 ? void 0 : _a.compressed) {
+                        delete message.metadata.compressed;
+                    }
                     clientSequenceNumber = this.context.submitFn(protocol_definitions_1.MessageType.Operation, message.deserializedContent, true, // batch
                     message.metadata);
                 }
@@ -1086,26 +1118,6 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         this.pendingStateManager.onFlush();
     }
     orderSequentially(callback) {
-        // If flush mode is already TurnBased we are either
-        // nested in another orderSequentially, or
-        // the app is flushing manually, in which
-        // case this invocation doesn't own
-        // flushing.
-        if (this.flushMode === runtime_definitions_1.FlushMode.TurnBased) {
-            this.trackOrderSequentiallyCalls(callback);
-            return;
-        }
-        const savedFlushMode = this.flushMode;
-        this.setFlushMode(runtime_definitions_1.FlushMode.TurnBased);
-        try {
-            this.trackOrderSequentiallyCalls(callback);
-            this.flush();
-        }
-        finally {
-            this.setFlushMode(savedFlushMode);
-        }
-    }
-    trackOrderSequentiallyCalls(callback) {
         let checkpoint;
         if (this.mc.config.getBoolean("Fluid.ContainerRuntime.EnableRollback")) {
             // Note: we are not touching this.pendingAttachBatch here, for two reasons:
@@ -1140,6 +1152,9 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         finally {
             this._orderSequentiallyCalls--;
         }
+        if (this.flushMode === runtime_definitions_1.FlushMode.Immediate && this._orderSequentiallyCalls === 0) {
+            this.flush();
+        }
     }
     async createDataStore(pkg) {
         const internalId = (0, uuid_1.v4)();
@@ -1166,6 +1181,12 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
     canSendOps() {
         return this.connected && !this.deltaManager.readOnlyInfo.readonly;
     }
+    /**
+     * Are we in the middle of batching ops together?
+     */
+    currentlyBatching() {
+        return this.flushMode === runtime_definitions_1.FlushMode.TurnBased || this._orderSequentiallyCalls !== 0;
+    }
     getQuorum() {
         return this.context.quorum;
     }
@@ -1316,10 +1337,8 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
      * Implementation of IGarbageCollectionRuntime::updateUsedRoutes.
      * After GC has run, called to notify this container's nodes of routes that are used in it.
      * @param usedRoutes - The routes that are used in all nodes in this Container.
-     * @param gcTimestamp - The time when GC was run that generated these used routes. If any node node becomes
-     * unreferenced as part of this GC run, this should be used to update the time when it happens.
      */
-    updateUsedRoutes(usedRoutes, gcTimestamp) {
+    updateUsedRoutes(usedRoutes) {
         // Update our summarizer node's used routes. Updating used routes in summarizer node before
         // summarizing is required and asserted by the the summarizer node. We are the root and are
         // always referenced, so the used routes is only self-route (empty string).
@@ -1330,14 +1349,16 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 dataStoreUsedRoutes.push(route);
             }
         }
-        return this.dataStores.updateUsedRoutes(dataStoreUsedRoutes, gcTimestamp);
+        return this.dataStores.updateUsedRoutes(dataStoreUsedRoutes);
     }
     /**
-     * When running GC in test mode, this is called to delete objects whose routes are unused. This enables testing
-     * scenarios with accessing deleted content.
+     * This is called to update objects whose routes are unused. The unused objects are either deleted or marked as
+     * tombstones.
      * @param unusedRoutes - The routes that are unused in all data stores in this Container.
+     * @param tombstone - if true, the objects corresponding to unused routes are marked tombstones. Otherwise, they
+     * are deleted.
      */
-    deleteUnusedRoutes(unusedRoutes) {
+    updateUnusedRoutes(unusedRoutes, tombstone) {
         const blobManagerUnusedRoutes = [];
         const dataStoreUnusedRoutes = [];
         for (const route of unusedRoutes) {
@@ -1348,8 +1369,11 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 dataStoreUnusedRoutes.push(route);
             }
         }
-        this.blobManager.deleteUnusedRoutes(blobManagerUnusedRoutes);
-        this.dataStores.deleteUnusedRoutes(dataStoreUnusedRoutes);
+        // Todo: Add tombstone for attachment blobs. For now, we ignore attachment blobs that should be tombstoned.
+        if (!tombstone) {
+            this.blobManager.deleteUnusedRoutes(blobManagerUnusedRoutes);
+        }
+        this.dataStores.updateUnusedRoutes(dataStoreUnusedRoutes, tombstone);
     }
     /**
      * Returns a server generated referenced timestamp to be used to track unreferenced nodes by GC.
@@ -1435,15 +1459,8 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             const latestSnapshotInfo = await this.refreshLatestSummaryAckFromServer(telemetry_utils_1.ChildLogger.create(summaryNumberLogger, undefined, { all: { safeSummary: true } }));
             const latestSnapshotRefSeq = latestSnapshotInfo.latestSnapshotRefSeq;
             latestSnapshotVersionId = latestSnapshotInfo.latestSnapshotVersionId;
-            if (latestSnapshotRefSeq > this.deltaManager.lastSequenceNumber) {
-                // We need to catch up to the latest summary's reference sequence number before pausing.
-                await telemetry_utils_1.PerformanceEvent.timedExecAsync(summaryNumberLogger, {
-                    eventName: "WaitingForSeq",
-                    lastSequenceNumber: this.deltaManager.lastSequenceNumber,
-                    targetSequenceNumber: latestSnapshotRefSeq,
-                    lastKnownSeqNumber: this.deltaManager.lastKnownSeqNumber,
-                }, async () => waitForSeq(this.deltaManager, latestSnapshotRefSeq), { start: true, end: true, cancel: "error" });
-            }
+            // We might need to catch up to the latest summary's reference sequence number before pausing.
+            await this.waitForDeltaManagerToCatchup(latestSnapshotRefSeq, summaryNumberLogger);
         }
         try {
             await this.deltaManager.inbound.pause();
@@ -1680,6 +1697,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         return this.blobManager.createBlob(blob);
     }
     submit(type, contents, localOpMetadata = undefined, metadata = undefined) {
+        var _a, _b, _c, _d;
         this.verifyNotClosed();
         // There should be no ops in detached container state!
         (0, common_utils_1.assert)(this.attachState !== container_definitions_1.AttachState.Detached, 0x132 /* "sending ops in detached container" */);
@@ -1716,8 +1734,8 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             //    issue than sending.
             // 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 (type === ContainerMessageType.Attach &&
-                this.mc.config.getBoolean("Fluid.ContainerRuntime.disableAttachOpReorder") !== true) {
+            if (this.currentlyBatching() && type === ContainerMessageType.Attach &&
+                this.mc.config.getBoolean("Fluid.ContainerRuntime.enableAttachOpReorder") === true) {
                 if (!this.pendingAttachBatch.push(message)) {
                     // BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
                     // when queue is not empty.
@@ -1726,9 +1744,9 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                     if (!this.pendingAttachBatch.push(message)) {
                         throw new container_utils_1.GenericError("BatchTooLarge", 
                         /* error */ undefined, {
-                            opSize: message.contents.length,
+                            opSize: (_b = ((_a = message.contents) === null || _a === void 0 ? void 0 : _a.length)) !== null && _b !== void 0 ? _b : 0,
                             count: this.pendingAttachBatch.length,
-                            limit: this.pendingAttachBatch.limit,
+                            limit: this.pendingAttachBatch.options.hardLimit,
                         });
                     }
                 }
@@ -1737,23 +1755,23 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 if (!this.pendingBatch.push(message)) {
                     throw new container_utils_1.GenericError("BatchTooLarge", 
                     /* error */ undefined, {
-                        opSize: message.contents.length,
+                        opSize: (_d = ((_c = message.contents) === null || _c === void 0 ? void 0 : _c.length)) !== null && _d !== void 0 ? _d : 0,
                         count: this.pendingBatch.length,
-                        limit: this.pendingBatch.limit,
+                        limit: this.pendingBatch.options.hardLimit,
                     });
                 }
-            }
-            if (this._flushMode !== runtime_definitions_1.FlushMode.TurnBased) {
-                this.flush();
-            }
-            else if (!this.flushTrigger) {
-                this.flushTrigger = true;
-                // Queue a microtask to detect the end of the turn and force a flush.
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                Promise.resolve().then(() => {
-                    this.flushTrigger = false;
+                if (!this.currentlyBatching()) {
                     this.flush();
-                });
+                }
+                else if (!this.flushMicroTaskExists) {
+                    this.flushMicroTaskExists = true;
+                    // Queue a microtask to detect the end of the turn and force a flush.
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    Promise.resolve().then(() => {
+                        this.flushMicroTaskExists = false;
+                        this.flush();
+                    });
+                }
             }
         }
         catch (error) {
@@ -1823,18 +1841,41 @@ class ContainerRuntime extends common_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(proposalHandle, ackHandle, summaryRefSeq, summaryLogger) {
+    async refreshLatestSummaryAck(options) {
+        const { proposalHandle, ackHandle, summaryRefSeq, summaryLogger } = options;
         const readAndParseBlob = async (id) => (0, driver_utils_1.readAndParse)(this.storage, id);
         // The call to fetch the snapshot is very expensive and not always needed.
         // It should only be done by the summarizerNode, if required.
+        // When fetching from storage we will always get the latest version and do not use the ackHandle.
         const snapshotTreeFetcher = async () => {
-            const fetchResult = await this.fetchSnapshotFromStorage(ackHandle, summaryLogger, {
+            const fetchResult = await this.fetchSnapshotFromStorage(null, summaryLogger, {
                 eventName: "RefreshLatestSummaryGetSnapshot",
                 ackHandle,
                 summaryRefSeq,
-                fetchLatest: false,
+                fetchLatest: true,
+            });
+            const latestSnapshotRefSeq = await (0, runtime_utils_1.seqFromTree)(fetchResult.snapshotTree, readAndParseBlob);
+            summaryLogger.sendTelemetryEvent({
+                eventName: "LatestSummaryRetrieved",
+                ackHandle,
+                lastSequenceNumber: latestSnapshotRefSeq,
+                targetSequenceNumber: summaryRefSeq,
             });
+            // In case we had to retrieve the latest snapshot and it is different than summaryRefSeq,
+            // wait for the delta manager to catch up before refreshing the latest Summary.
+            await this.waitForDeltaManagerToCatchup(latestSnapshotRefSeq, summaryLogger);
             return fetchResult.snapshotTree;
         };
         const result = await this.summarizerNode.refreshLatestSummary(proposalHandle, summaryRefSeq, snapshotTreeFetcher, readAndParseBlob, summaryLogger);
@@ -1879,7 +1920,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             this.baseSnapshotBlobs = serializedSnapshotStorage_1.SerializedSnapshotStorage.serializeTreeWithBlobContents(snapshot);
         }
     }
-    async getSnapshotBlobs() {
+    async initializeBaseSnapshotBlobs() {
         var _a;
         if (!((_a = this.mc.config.getBoolean("enableOfflineLoad")) !== null && _a !== void 0 ? _a : this.runtimeOptions.enableOfflineLoad) ||
             this.attachState !== container_definitions_1.AttachState.Attached || this.context.pendingLocalState) {
@@ -1897,6 +1938,9 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         // getPendingLocalState() is only exposed through Container.closeAndGetPendingLocalState(), so it's safe
         // to close current batch.
         this.flush();
+        if (this._orderSequentiallyCalls !== 0) {
+            throw new container_utils_1.UsageError("can't get state during orderSequentially");
+        }
         const previousPendingState = this.context.pendingLocalState;
         if (previousPendingState) {
             return {
@@ -1964,6 +2008,9 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 throw new container_utils_1.UsageError(`Summary heuristic configuration property "${prop}" cannot be less than 0`);
             }
         }
+        if (configuration.minIdleTime > configuration.maxIdleTime) {
+            throw new container_utils_1.UsageError(`"minIdleTime" [${configuration.minIdleTime}] cannot be greater than "maxIdleTime" [${configuration.maxIdleTime}]`);
+        }
     }
 }
 exports.ContainerRuntime = ContainerRuntime;
@@ -1974,12 +2021,18 @@ exports.ContainerRuntime = ContainerRuntime;
 const waitForSeq = async (deltaManager, targetSeq) => new Promise((resolve, reject) => {
     // TODO: remove cast to any when actual event is determined
     deltaManager.on("closed", reject);
-    const handleOp = (message) => {
-        if (message.sequenceNumber >= targetSeq) {
-            resolve();
-            deltaManager.off("op", handleOp);
-        }
-    };
-    deltaManager.on("op", handleOp);
+    // 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