@fluidframework/container-runtime 0.52.0 → 0.54.0-47413

package/lib/containerRuntime.js

@@ -2,34 +2,33 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { AttachState, } from "@fluidframework/container-definitions";
+import { AttachState, LoaderHeader, } from "@fluidframework/container-definitions";
 import { assert, Trace, TypedEventEmitter, unreachableCase, performance, } from "@fluidframework/common-utils";
-import { ChildLogger, raiseConnectedEvent, PerformanceEvent, normalizeError, TaggedLoggerAdapter, } from "@fluidframework/telemetry-utils";
+import { ChildLogger, raiseConnectedEvent, PerformanceEvent, normalizeError, TaggedLoggerAdapter, loggerToMonitoringContext, } from "@fluidframework/telemetry-utils";
+import { DriverHeader } from "@fluidframework/driver-definitions";
 import { readAndParse, BlobAggregationStorage } from "@fluidframework/driver-utils";
-import { DataCorruptionError, GenericError, extractSafePropertiesFromMessage } from "@fluidframework/container-utils";
-import { BlobTreeEntry, TreeTreeEntry, } from "@fluidframework/protocol-base";
+import { CreateProcessingError, DataCorruptionError, GenericError, UsageError, extractSafePropertiesFromMessage, } from "@fluidframework/container-utils";
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { FlushMode, channelsTreeName, } from "@fluidframework/runtime-definitions";
-import { addBlobToSummary, addTreeToSummary, convertToSummaryTree, createRootSummarizerNodeWithGC, FluidSerializer, RequestParser, create404Response, exceptionToResponse, responseToException, seqFromTree, } from "@fluidframework/runtime-utils";
+import { addBlobToSummary, addTreeToSummary, convertToSummaryTree, createRootSummarizerNodeWithGC, RequestParser, create404Response, exceptionToResponse, requestFluidObject, responseToException, seqFromTree, convertSummaryTreeToITree, } from "@fluidframework/runtime-utils";
 import { v4 as uuid } from "uuid";
 import { ContainerFluidHandleContext } from "./containerHandleContext";
 import { FluidDataStoreRegistry } from "./dataStoreRegistry";
 import { Summarizer } from "./summarizer";
-import { formRequestSummarizerFn, SummaryManager } from "./summaryManager";
+import { SummaryManager } from "./summaryManager";
 import { DeltaScheduler } from "./deltaScheduler";
 import { ReportOpPerfTelemetry, latencyThreshold } from "./connectionTelemetry";
 import { PendingStateManager } from "./pendingStateManager";
 import { pkgVersion } from "./packageVersion";
 import { BlobManager } from "./blobManager";
 import { DataStores, getSummaryForDatastores } from "./dataStores";
-import { blobsTreeName, chunksBlobName, electedSummarizerBlobName, extractSummaryMetadataMessage, metadataBlobName, wrapSummaryInChannelsTree, } from "./summaryFormat";
+import { aliasBlobName, blobsTreeName, chunksBlobName, electedSummarizerBlobName, extractSummaryMetadataMessage, metadataBlobName, wrapSummaryInChannelsTree, } from "./summaryFormat";
 import { SummaryCollection } from "./summaryCollection";
-import { getLocalStorageFeatureGate } from "./localStorageFeatureGates";
 import { OrderedClientCollection, OrderedClientElection } from "./orderedClientElection";
 import { SummarizerClientElection, summarizerClientType } from "./summarizerClientElection";
 import { formExponentialFn, Throttler } from "./throttler";
 import { RunWhileConnectedCoordinator } from "./runWhileConnectedCoordinator";
-import { GarbageCollector, } from "./garbageCollection";
+import { GarbageCollector, gcTreeKey, } from "./garbageCollection";
 export var ContainerMessageType;
 (function (ContainerMessageType) {
     // An op to be delivered to store
@@ -42,6 +41,8 @@ export var ContainerMessageType;
     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";
 })(ContainerMessageType || (ContainerMessageType = {}));
 // Consider idle 5s of no activity. And snapshot if a minute has gone by with no snapshot.
 const IdleDetectionTime = 5000;
@@ -56,12 +57,13 @@ const DefaultSummaryConfiguration = {
     maxAckWaitTime: 120000,
 };
 // Local storage key to set the default flush mode to TurnBased
-const turnBasedFlushModeKey = "FluidFlushModeTurnBased";
+const turnBasedFlushModeKey = "Fluid.ContainerRuntime.FlushModeTurnBased";
 export function isRuntimeMessage(message) {
     switch (message.type) {
         case ContainerMessageType.FluidDataStoreOp:
         case ContainerMessageType.ChunkedOp:
         case ContainerMessageType.Attach:
+        case ContainerMessageType.Alias:
         case ContainerMessageType.BlobAttach:
         case ContainerMessageType.Rejoin:
         case MessageType.Operation:
@@ -306,13 +308,27 @@ export class ScheduleManager {
  * ContainerRuntime's perspective.
  */
 export const agentSchedulerId = "_scheduler";
+// safely check navigator and get the hardware spec value
+export function getDeviceSpec() {
+    try {
+        if (typeof navigator === "object" && navigator !== null) {
+            return {
+                deviceMemory: navigator.deviceMemory,
+                hardwareConcurrency: navigator.hardwareConcurrency,
+            };
+        }
+    }
+    catch (_a) {
+    }
+    return {};
+}
 /**
  * Represents the runtime of the container. Contains helper functions/state of the container.
  * It will define the store level mappings.
  */
 export class ContainerRuntime extends TypedEventEmitter {
-    constructor(context, registry, metadata, electedSummarizerData, chunks, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, requestHandler, _storage) {
-        var _a, _b, _c, _d;
+    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, requestHandler, _storage) {
+        var _a, _b, _c, _d, _e;
         super();
         this.context = context;
         this.registry = registry;
@@ -321,14 +337,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.logger = logger;
         this.requestHandler = requestHandler;
         this._storage = _storage;
-        // back-compat: Used by loader in <= 0.35
-        /**
-         * @internal
-         * @deprecated Back-compat only. Used by the loader in versions earlier than 0.35.
-         */
-        this.runtimeVersion = pkgVersion;
         this._orderSequentiallyCalls = 0;
-        this._flushMode = ContainerRuntime.defaultFlushMode;
         this.needsFlush = false;
         this.flushTrigger = false;
         this.paused = false;
@@ -371,7 +380,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // If we're not the summarizer, and we don't have a summaryManager, we expect that
                 // disableSummaries is turned on. We are throwing instead of returning a failure here,
                 // because it is a misuse of the API rather than an expected failure.
-                throw new Error(`Can't summarize, disableSummaries: ${this.summariesDisabled()}`);
+                throw new UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
             }
         };
         this.enqueueSummarize = (...args) => {
@@ -385,18 +394,47 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // If we're not the summarizer, and we don't have a summaryManager, we expect that
                 // generateSummaries is turned off. We are throwing instead of returning a failure here,
                 // because it is a misuse of the API rather than an expected failure.
-                throw new Error(`Can't summarize, disableSummaries: ${this.summariesDisabled()}`);
+                throw new UsageError(`Can't summarize, disableSummaries: ${this.summariesDisabled}`);
             }
         };
         this.baseSummaryMessage = metadata === null || metadata === void 0 ? void 0 : metadata.message;
+        // If this is an existing container, we get values from metadata.
+        // otherwise, we initialize them.
+        if (existing) {
+            this.createContainerMetadata = {
+                createContainerRuntimeVersion: metadata === null || metadata === void 0 ? void 0 : metadata.createContainerRuntimeVersion,
+                createContainerTimestamp: metadata === null || metadata === void 0 ? void 0 : metadata.createContainerTimestamp,
+            };
+            this.summaryCount = metadata === null || metadata === void 0 ? void 0 : metadata.summaryCount;
+        }
+        else {
+            this.createContainerMetadata = {
+                createContainerRuntimeVersion: pkgVersion,
+                createContainerTimestamp: Date.now(),
+            };
+        }
         // Default to false (enabled).
         this.disableIsolatedChannels = (_a = this.runtimeOptions.summaryOptions.disableIsolatedChannels) !== null && _a !== void 0 ? _a : false;
         this._connected = this.context.connected;
         this.chunkMap = new Map(chunks);
-        this.IFluidHandleContext = new ContainerFluidHandleContext("", this);
-        this.IFluidSerializer = new FluidSerializer(this.IFluidHandleContext);
-        this._logger = ChildLogger.create(this.logger, "ContainerRuntime");
-        this.garbageCollector = GarbageCollector.create(this, this.runtimeOptions.gcOptions, (unusedRoutes) => this.dataStores.deleteUnusedRoutes(unusedRoutes), this._logger, existing, metadata);
+        this.handleContext = new ContainerFluidHandleContext("", this);
+        this.mc = loggerToMonitoringContext(ChildLogger.create(this.logger, "ContainerRuntime"));
+        this._flushMode =
+            ((_b = this.mc.config.getBoolean(turnBasedFlushModeKey)) !== null && _b !== void 0 ? _b : false) ? FlushMode.TurnBased : FlushMode.Immediate;
+        /**
+         * Function that return the current server timestamp. This is used by the garbage collector to set the
+         * time when a node becomes unreferenced.
+         * We use the timestamp of the last op for current timestamp. However, there can be cases where
+         * we don't have an op (on demand summaries for instance). In those cases, we will use the timestamp
+         * of this client's connection.
+         */
+        const getCurrentTimestamp = () => {
+            var _a, _b, _c;
+            const client = this.clientId !== undefined ? this.getAudience().getMember(this.clientId) : undefined;
+            const timestamp = client === null || client === void 0 ? void 0 : client.timestamp;
+            return (_c = (_b = (_a = this.deltaManager.lastMessage) === null || _a === void 0 ? void 0 : _a.timestamp) !== null && _b !== void 0 ? _b : timestamp) !== null && _c !== void 0 ? _c : Date.now();
+        };
+        this.garbageCollector = GarbageCollector.create(this, this.runtimeOptions.gcOptions, (unusedRoutes) => this.dataStores.deleteUnusedRoutes(unusedRoutes), getCurrentTimestamp, context.baseSnapshot, async (id) => readAndParse(this.storage, id), this.mc.logger, existing, metadata);
         const loadedFromSequenceNumber = this.deltaManager.initialSequenceNumber;
         this.summarizerNode = createRootSummarizerNodeWithGC(ChildLogger.create(this.logger, "SummarizerNode"), 
         // Summarize function to call when summarize is called. Summarizer node always tracks summary state.
@@ -413,69 +451,58 @@ export class ContainerRuntime extends TypedEventEmitter {
             throwOnFailure: true,
             // If GC should not run, let the summarizer node know so that it does not track GC state.
             gcDisabled: !this.garbageCollector.shouldRunGC,
-            // The max duration for which objects can be unreferenced before they are eligible for deletion.
-            maxUnreferencedDurationMs: this.runtimeOptions.gcOptions.maxUnreferencedDurationMs,
         });
         if (this.context.baseSnapshot) {
             this.summarizerNode.loadBaseSummaryWithoutDifferential(this.context.baseSnapshot);
         }
-        this.dataStores = new DataStores(getSummaryForDatastores(context.baseSnapshot, metadata), this, (attachMsg) => this.submit(ContainerMessageType.Attach, attachMsg), (id, createParam) => (summarizeInternal, getGCDataFn, getInitialGCSummaryDetailsFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn, getInitialGCSummaryDetailsFn), (id) => this.summarizerNode.deleteChild(id), this._logger);
-        this.blobManager = new BlobManager(this.IFluidHandleContext, blobManagerSnapshot, () => this.storage, (blobId) => this.submit(ContainerMessageType.BlobAttach, undefined, undefined, { blobId }), this, this.logger);
+        this.dataStores = new DataStores(getSummaryForDatastores(context.baseSnapshot, metadata), this, (attachMsg) => this.submit(ContainerMessageType.Attach, attachMsg), (id, createParam) => (summarizeInternal, getGCDataFn, getInitialGCSummaryDetailsFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn, getInitialGCSummaryDetailsFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, async () => this.garbageCollector.getDataStoreBaseGCDetails(), (id) => this.garbageCollector.nodeChanged(id), new Map(dataStoreAliasMap));
+        this.blobManager = new BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (blobId) => this.submit(ContainerMessageType.BlobAttach, undefined, undefined, { blobId }), this, this.logger);
         this.scheduleManager = new ScheduleManager(context.deltaManager, this, ChildLogger.create(this.logger, "ScheduleManager"));
         this.deltaSender = this.deltaManager;
         this.pendingStateManager = new PendingStateManager(this, async (type, content) => this.applyStashedOp(type, content), context.pendingLocalState);
         this.context.quorum.on("removeMember", (clientId) => {
             this.clearPartialChunks(clientId);
         });
-        this.context.quorum.on("addProposal", (proposal) => {
-            if (proposal.key === "code" || proposal.key === "code2") {
-                this.emit("codeDetailsProposed", proposal.value, proposal);
-            }
-        });
         this.summaryCollection = new SummaryCollection(this.deltaManager, this.logger);
-        // Only create a SummaryManager if summaries are enabled and we are not the summarizer client
         // Map the deprecated generateSummaries flag to disableSummaries.
         if (this.runtimeOptions.summaryOptions.generateSummaries === false) {
             this.runtimeOptions.summaryOptions.disableSummaries = true;
         }
-        if (this.summariesDisabled()) {
-            this._logger.sendTelemetryEvent({ eventName: "SummariesDisabled" });
+        if (this.summariesDisabled) {
+            this.mc.logger.sendTelemetryEvent({ eventName: "SummariesDisabled" });
         }
         else {
-            const maxOpsSinceLastSummary = (_b = this.runtimeOptions.summaryOptions.maxOpsSinceLastSummary) !== null && _b !== void 0 ? _b : 7000;
-            const defaultAction = () => {
-                if (this.summaryCollection.opsSinceLastAck > maxOpsSinceLastSummary) {
-                    this.logger.sendErrorEvent({ 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
-                    this.summaryCollection.once(MessageType.SummaryAck, () => {
-                        this.logger.sendTelemetryEvent({ eventName: "SummaryStatus:CaughtUp" });
-                        // we've caught up, so re-register the default action to monitor for
-                        // falling behind, and unregister ourself
-                        this.summaryCollection.on("default", defaultAction);
-                    });
-                    this.summaryCollection.off("default", defaultAction);
-                }
-            };
-            this.summaryCollection.on("default", defaultAction);
             const orderedClientLogger = ChildLogger.create(this.logger, "OrderedClientElection");
             const orderedClientCollection = new OrderedClientCollection(orderedClientLogger, this.context.deltaManager, this.context.quorum);
             const orderedClientElectionForSummarizer = new OrderedClientElection(orderedClientLogger, orderedClientCollection, electedSummarizerData !== null && electedSummarizerData !== void 0 ? electedSummarizerData : this.context.deltaManager.lastSequenceNumber, SummarizerClientElection.isClientEligible);
-            const summarizerClientElectionEnabled = (_c = getLocalStorageFeatureGate("summarizerClientElection")) !== null && _c !== void 0 ? _c : ((_d = this.runtimeOptions.summaryOptions) === null || _d === void 0 ? void 0 : _d.summarizerClientElection) === true;
+            const summarizerClientElectionEnabled = (_c = this.mc.config.getBoolean("Fluid.ContainerRuntime.summarizerClientElection")) !== null && _c !== void 0 ? _c : ((_d = this.runtimeOptions.summaryOptions) === null || _d === void 0 ? void 0 : _d.summarizerClientElection) === true;
+            const maxOpsSinceLastSummary = (_e = this.runtimeOptions.summaryOptions.maxOpsSinceLastSummary) !== null && _e !== void 0 ? _e : 7000;
             this.summarizerClientElection = new SummarizerClientElection(orderedClientLogger, this.summaryCollection, orderedClientElectionForSummarizer, maxOpsSinceLastSummary, summarizerClientElectionEnabled);
             if (this.context.clientDetails.type === summarizerClientType) {
-                this._summarizer = new Summarizer("/_summarizer", this /* ISummarizerRuntime */, () => this.summaryConfiguration, this /* ISummarizerInternalsProvider */, this.IFluidHandleContext, this.summaryCollection, async (runtime) => RunWhileConnectedCoordinator.create(runtime));
+                this._summarizer = new Summarizer("/_summarizer", this /* ISummarizerRuntime */, () => this.summaryConfiguration, this /* ISummarizerInternalsProvider */, this.handleContext, this.summaryCollection, async (runtime) => RunWhileConnectedCoordinator.create(runtime));
             }
             else if (SummarizerClientElection.clientDetailsPermitElection(this.context.clientDetails)) {
-                // Create the SummaryManager and mark the initial state
-                const requestOptions = {
-                    cache: false,
-                    reconnect: false,
-                    summarizingClient: true,
+                // Only create a SummaryManager and SummarizerClientElection
+                // if summaries are enabled and we are not the summarizer client.
+                const defaultAction = () => {
+                    if (this.summaryCollection.opsSinceLastAck > maxOpsSinceLastSummary) {
+                        this.logger.sendErrorEvent({ 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
+                        this.summaryCollection.once(MessageType.SummaryAck, () => {
+                            this.logger.sendTelemetryEvent({ eventName: "SummaryStatus:CaughtUp" });
+                            // we've caught up, so re-register the default action to monitor for
+                            // falling behind, and unregister ourself
+                            this.summaryCollection.on("default", defaultAction);
+                        });
+                        this.summaryCollection.off("default", defaultAction);
+                    }
                 };
+                this.summaryCollection.on("default", defaultAction);
+                // Create the SummaryManager and mark the initial state
                 this.summaryManager = new SummaryManager(this.summarizerClientElection, this, // IConnectedState
-                this.summaryCollection, this.logger, formRequestSummarizerFn(this.context.loader, this.context.deltaManager.lastSequenceNumber, requestOptions), new Throttler(60 * 1000, // 60 sec delay window
+                this.summaryCollection, this.logger, this.formRequestSummarizerFn(this.context.loader), new Throttler(60 * 1000, // 60 sec delay window
                 30 * 1000, // 30 sec max delay
                 // throttling function increases exponentially (0ms, 40ms, 80ms, 160ms, etc)
                 formExponentialFn({ coefficient: 20, initialDelay: 0 })), {
@@ -488,7 +515,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         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.
-            assert(readonly === this.deltaManager.readonly, 0x124 /* "inconsistent readonly property/event state" */);
+            assert(readonly === this.deltaManager.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)
@@ -507,6 +534,10 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (context.pendingLocalState !== undefined) {
             this.deltaManager.on("op", this.onOp);
         }
+        // logging hardware telemetry
+        logger.sendTelemetryEvent(Object.assign({ eventName: "DeviceSpec" }, getDeviceSpec()));
+        // logging container load stats
+        this.logger.sendTelemetryEvent(Object.assign(Object.assign(Object.assign({ eventName: "ContainerLoadStats" }, this.createContainerMetadata), this.dataStores.containerLoadStats), { summaryCount: this.summaryCount, 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 }));
         ReportOpPerfTelemetry(this.context.clientId, this.deltaManager, this.logger);
     }
     get IContainerRuntime() { return this; }
@@ -520,7 +551,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      * @param existing - (optional) When loading from an existing snapshot. Precedes context.existing if provided
      */
     static async load(context, registryEntries, requestHandler, runtimeOptions = {}, containerScope = context.scope, existing) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         // If taggedLogger exists, use it. Otherwise, wrap the vanilla logger:
         const passLogger = (_a = context.taggedLogger) !== null && _a !== void 0 ? _a : new TaggedLoggerAdapter(context.logger);
         const logger = ChildLogger.create(passLogger, undefined, {
@@ -562,19 +593,22 @@ export class ContainerRuntime extends TypedEventEmitter {
                 return readAndParse(storage, blobId);
             }
         };
-        const chunks = (_b = await tryFetchBlob(chunksBlobName)) !== null && _b !== void 0 ? _b : [];
-        const metadata = await tryFetchBlob(metadataBlobName);
-        const electedSummarizerData = await tryFetchBlob(electedSummarizerBlobName);
+        const [chunks, metadata, electedSummarizerData, aliases] = await Promise.all([
+            tryFetchBlob(chunksBlobName),
+            tryFetchBlob(metadataBlobName),
+            tryFetchBlob(electedSummarizerBlobName),
+            tryFetchBlob(aliasBlobName),
+        ]);
         const loadExisting = existing === true || context.existing === true;
         // read snapshot blobs needed for BlobManager to load
-        const blobManagerSnapshot = await BlobManager.load((_c = context.baseSnapshot) === null || _c === void 0 ? void 0 : _c.trees[blobsTreeName], async (id) => {
+        const blobManagerSnapshot = await BlobManager.load((_b = context.baseSnapshot) === null || _b === void 0 ? void 0 : _b.trees[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.
             assert(storage !== undefined, 0x256 /* "storage undefined in attached container" */);
             return readAndParse(storage, id);
         });
         // Verify summary runtime sequence number matches protocol sequence number.
-        const runtimeSequenceNumber = (_d = metadata === null || metadata === void 0 ? void 0 : metadata.message) === null || _d === void 0 ? void 0 : _d.sequenceNumber;
+        const runtimeSequenceNumber = (_c = metadata === null || metadata === void 0 ? void 0 : metadata.message) === null || _c === void 0 ? void 0 : _c.sequenceNumber;
         if (runtimeSequenceNumber !== undefined) {
             const protocolSequenceNumber = context.deltaManager.initialSequenceNumber;
             // Unless bypass is explicitly set, then take action when sequence numbers mismatch.
@@ -589,13 +623,16 @@ export class ContainerRuntime extends TypedEventEmitter {
                 }
             }
         }
-        const runtime = new ContainerRuntime(context, registry, metadata, electedSummarizerData, chunks, {
+        const runtime = new ContainerRuntime(context, registry, metadata, electedSummarizerData, chunks !== null && chunks !== void 0 ? chunks : [], aliases !== null && aliases !== void 0 ? aliases : [], {
             summaryOptions,
             gcOptions,
             loadSequenceNumberVerification,
         }, containerScope, logger, loadExisting, blobManagerSnapshot, requestHandler, storage);
         return runtime;
     }
+    /**
+    * @deprecated This will be removed in a later release. Deprecated in 0.53
+    */
     get id() {
         return this.context.id;
     }
@@ -646,6 +683,9 @@ export class ContainerRuntime extends TypedEventEmitter {
     get attachState() {
         return this.context.attachState;
     }
+    get IFluidHandleContext() {
+        return this.handleContext;
+    }
     get connected() {
         return this._connected;
     }
@@ -659,13 +699,22 @@ export class ContainerRuntime extends TypedEventEmitter {
         return Object.assign(Object.assign(Object.assign({}, DefaultSummaryConfiguration), (_b = (_a = this.context) === null || _a === void 0 ? void 0 : _a.serviceConfiguration) === null || _b === void 0 ? void 0 : _b.summary), (_c = this.runtimeOptions.summaryOptions) === null || _c === void 0 ? void 0 : _c.summaryConfigOverrides);
     }
     get disposed() { return this._disposed; }
-    static get defaultFlushMode() {
-        return getLocalStorageFeatureGate(turnBasedFlushModeKey) ? FlushMode.TurnBased : FlushMode.Immediate;
+    /**
+     * True, if GC data should be written at root of the summary tree.
+     * False, if data stores should write GC blobs in their summary tree.
+     */
+    get writeGCDataAtRoot() {
+        return this.garbageCollector.writeDataAtRoot;
     }
     get summarizer() {
         assert(this._summarizer !== undefined, 0x257 /* "This is not summarizing container" */);
         return this._summarizer;
     }
+    get summariesDisabled() {
+        var _a;
+        return this.runtimeOptions.summaryOptions.disableSummaries === true ||
+            ((_a = this.runtimeOptions.summaryOptions.summaryConfigOverrides) === null || _a === void 0 ? void 0 : _a.disableSummaries) === true;
+    }
     dispose(error) {
         var _a;
         if (this._disposed) {
@@ -779,14 +828,10 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     formMetadata() {
         var _a;
-        return {
-            summaryFormatVersion: 1,
-            disableIsolatedChannels: this.disableIsolatedChannels || undefined,
-            gcFeature: this.garbageCollector.gcSummaryFeatureVersion,
+        return Object.assign(Object.assign({}, this.createContainerMetadata), { summaryCount: this.summaryCount, summaryFormatVersion: 1, disableIsolatedChannels: this.disableIsolatedChannels || undefined, gcFeature: this.garbageCollector.gcSummaryFeatureVersion, 
             // The last message processed at the time of summary. If there are no messages, nothing has changed from
             // the base summary we loaded from. So, use the message from its metadata blob.
-            message: (_a = extractSummaryMetadataMessage(this.deltaManager.lastMessage)) !== null && _a !== void 0 ? _a : this.baseSummaryMessage,
-        };
+            message: (_a = extractSummaryMetadataMessage(this.deltaManager.lastMessage)) !== null && _a !== void 0 ? _a : this.baseSummaryMessage });
     }
     /**
      * Retrieves the runtime for a data store if it's referenced as per the initially summary that it is loaded with.
@@ -813,22 +858,14 @@ export class ContainerRuntime extends TypedEventEmitter {
      * @deprecated - Use summarize to get summary of the container runtime.
      */
     async snapshot() {
-        if (this.garbageCollector.shouldRunGC) {
-            await this.collectGarbage({ logger: this.logger, fullGC: true /* fullGC */ });
-        }
-        const root = { entries: [] };
-        const entries = await this.dataStores.snapshot();
-        if (this.disableIsolatedChannels) {
-            root.entries = root.entries.concat(entries);
-        }
-        else {
-            root.entries.push(new TreeTreeEntry(channelsTreeName, { entries }));
-        }
-        root.entries.push(new BlobTreeEntry(metadataBlobName, JSON.stringify(this.formMetadata())));
-        if (this.chunkMap.size > 0) {
-            root.entries.push(new BlobTreeEntry(chunksBlobName, JSON.stringify([...this.chunkMap])));
-        }
-        return root;
+        const summaryResult = await this.summarize({
+            summaryLogger: this.logger,
+            fullTree: true,
+            trackState: false,
+            runGC: this.garbageCollector.shouldRunGC,
+            fullGC: true,
+        });
+        return convertSummaryTreeToITree(summaryResult.summary);
     }
     addContainerBlobsToSummary(summaryTree) {
         var _a;
@@ -837,6 +874,10 @@ export class ContainerRuntime extends TypedEventEmitter {
             const content = JSON.stringify([...this.chunkMap]);
             addBlobToSummary(summaryTree, chunksBlobName, content);
         }
+        const dataStoreAliases = this.dataStores.aliases();
+        if (dataStoreAliases.size > 0) {
+            addBlobToSummary(summaryTree, aliasBlobName, JSON.stringify([...dataStoreAliases]));
+        }
         if (this.summarizerClientElection) {
             const electedSummarizerContent = JSON.stringify((_a = this.summarizerClientElection) === null || _a === void 0 ? void 0 : _a.serialize());
             addBlobToSummary(summaryTree, electedSummarizerBlobName, electedSummarizerContent);
@@ -848,6 +889,12 @@ export class ContainerRuntime extends TypedEventEmitter {
             const blobsTree = convertToSummaryTree(snapshot, false);
             addTreeToSummary(summaryTree, blobsTreeName, blobsTree);
         }
+        if (this.writeGCDataAtRoot) {
+            const gcSummary = this.garbageCollector.summarize();
+            if (gcSummary !== undefined) {
+                addTreeToSummary(summaryTree, gcTreeKey, gcSummary);
+            }
+        }
     }
     replayPendingStates() {
         // We need to be able to send ops to replay states
@@ -882,6 +929,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 return this.dataStores.applyStashedOp(op);
             case ContainerMessageType.Attach:
                 return this.dataStores.applyStashedAttachOp(op);
+            case ContainerMessageType.Alias:
             case ContainerMessageType.BlobAttach:
                 return;
             case ContainerMessageType.ChunkedOp:
@@ -903,7 +951,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.replayPendingStates();
         }
         this.dataStores.setConnectionState(connected, clientId);
-        raiseConnectedEvent(this._logger, this, connected, clientId);
+        raiseConnectedEvent(this.mc.logger, this, connected, clientId);
     }
     process(messageArg, local) {
         var _a;
@@ -937,6 +985,9 @@ export class ContainerRuntime extends TypedEventEmitter {
                 case ContainerMessageType.Attach:
                     this.dataStores.processAttachMessage(message, local || localAck);
                     break;
+                case ContainerMessageType.Alias:
+                    this.processAliasMessage(message, localOpMetadata, local);
+                    break;
                 case ContainerMessageType.FluidDataStoreOp:
                     // if localAck === true, treat this as a local op because it's one we sent on a previous container
                     this.dataStores.processFluidDataStoreOp(message, local || localAck, localOpMetadata);
@@ -955,6 +1006,9 @@ export class ContainerRuntime extends TypedEventEmitter {
             throw e;
         }
     }
+    processAliasMessage(message, localOpMetadata, local) {
+        this.dataStores.processAliasMessage(message, localOpMetadata, local);
+    }
     processSignal(message, local) {
         const envelope = message.content;
         const transformed = {
@@ -1004,6 +1058,11 @@ export class ContainerRuntime extends TypedEventEmitter {
             return;
         }
         this.needsFlush = false;
+        // Did we disconnect in the middle of turn-based batch?
+        // If so, do nothing, as pending state manager will resubmit it correctly on reconnect.
+        if (!this.canSendOps()) {
+            return;
+        }
         return this.deltaSender.flush();
     }
     orderSequentially(callback) {
@@ -1020,11 +1079,12 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.setFlushMode(FlushMode.TurnBased);
         try {
             this.trackOrderSequentiallyCalls(callback);
-        }
-        finally {
             this.flush();
             this.setFlushMode(savedFlushMode);
         }
+        catch (error) {
+            this.closeFn(CreateProcessingError(error, "orderSequentially"));
+        }
     }
     trackOrderSequentiallyCalls(callback) {
         try {
@@ -1180,27 +1240,33 @@ export class ContainerRuntime extends 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.
      * @returns the statistics of the used state of the data stores.
      */
-    updateUsedRoutes(usedRoutes) {
-        var _a;
+    updateUsedRoutes(usedRoutes, gcTimestamp) {
         // 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).
         this.summarizerNode.updateUsedRoutes([""]);
-        return this.dataStores.updateUsedRoutes(usedRoutes, (_a = 
-        // For now, we use the timestamp of the last op for gcTimestamp. However, there can be cases where
-        // we don't have an op (on demand summaries for instance). In those cases, we will use the timestamp
-        // of this client's connection - https://github.com/microsoft/FluidFramework/issues/7152.
-        this.deltaManager.lastMessage) === null || _a === void 0 ? void 0 : _a.timestamp);
+        return this.dataStores.updateUsedRoutes(usedRoutes, gcTimestamp);
     }
     /**
-     * Runs garbage collection and udpates the reference / used state of the nodes in the container.
+     * Runs garbage collection and updates the reference / used state of the nodes in the container.
      * @returns the statistics of the garbage collection run.
      */
     async collectGarbage(options) {
         return this.garbageCollector.collectGarbage(options);
     }
+    /**
+     * Called when a new outbound reference is added to another node. This is used by garbage collection to identify
+     * all references added in the system.
+     * @param srcHandle - The handle of the node that added the reference.
+     * @param outboundHandle - The handle of the outbound node that is referenced.
+     */
+    addedGCOutboundReference(srcHandle, outboundHandle) {
+        this.garbageCollector.addedOutboundReference(srcHandle.absolutePath, outboundHandle.absolutePath);
+    }
     /**
      * Generates the summary tree, uploads it to storage, and then submits the summarize op.
      * This is intended to be called by the summarizer, since it is the implementation of
@@ -1260,6 +1326,13 @@ export class ContainerRuntime extends TypedEventEmitter {
             if (!continueResult.continue) {
                 return { stage: "base", referenceSequenceNumber: summaryRefSeqNum, error: continueResult.error };
             }
+            // increment summary count
+            if (this.summaryCount !== undefined) {
+                this.summaryCount++;
+            }
+            else {
+                this.summaryCount = 1;
+            }
             const trace = Trace.start();
             let summarizeResult;
             try {
@@ -1383,10 +1456,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.dirtyContainer = dirty;
         if (this.emitDirtyDocumentEvent) {
             this.emit(dirty ? "dirty" : "saved");
-            // back-compat: Loader API added in 0.35 only
-            if (this.context.updateDirtyContainerState !== undefined) {
-                this.context.updateDirtyContainerState(dirty);
-            }
+            this.context.updateDirtyContainerState(dirty);
         }
     }
     submitDataStoreOp(id, contents, localOpMetadata = undefined) {
@@ -1467,7 +1537,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         // That might be not what caller hopes to get, but we can look deeper if telemetry tells us it's a problem.
         const middleOfBatch = this.flushMode === FlushMode.TurnBased && this.needsFlush;
         if (middleOfBatch) {
-            this._logger.sendErrorEvent({ eventName: "submitSystemMessageError", type });
+            this.mc.logger.sendErrorEvent({ eventName: "submitSystemMessageError", type });
         }
         return this.context.submitFn(type, contents, middleOfBatch);
     }
@@ -1500,6 +1570,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.dataStores.resubmitDataStoreOp(content, localOpMetadata);
                 break;
             case ContainerMessageType.Attach:
+            case ContainerMessageType.Alias:
                 this.submit(type, content, localOpMetadata);
                 break;
             case ContainerMessageType.ChunkedOp:
@@ -1531,7 +1602,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      * @returns downloaded snapshot's reference sequence number
      */
     async refreshLatestSummaryAckFromServer(summaryLogger) {
-        const snapshot = await this.fetchSnapshotFromStorage(this.id, summaryLogger, {
+        const snapshot = await this.fetchSnapshotFromStorage(null, summaryLogger, {
             eventName: "RefreshLatestSummaryGetSnapshot",
             fetchLatest: true,
         });
@@ -1560,12 +1631,30 @@ export class ContainerRuntime extends TypedEventEmitter {
         return this.pendingStateManager.getLocalState();
     }
     /**
-     * @returns true if summaries are explicitly disabled for this ContainerRuntime, false otherwise
-     */
-    summariesDisabled() {
-        var _a;
-        return this.runtimeOptions.summaryOptions.disableSummaries === true ||
-            ((_a = this.runtimeOptions.summaryOptions.summaryConfigOverrides) === null || _a === void 0 ? void 0 : _a.disableSummaries) === true;
+     * * Forms a function that will request a Summarizer.
+     * @param loaderRouter - the loader acting as an IFluidRouter
+     * */
+    formRequestSummarizerFn(loaderRouter) {
+        return async () => {
+            const request = {
+                headers: {
+                    [LoaderHeader.cache]: false,
+                    [LoaderHeader.clientDetails]: {
+                        capabilities: { interactive: false },
+                        type: summarizerClientType,
+                    },
+                    [DriverHeader.summarizingClient]: true,
+                    [LoaderHeader.reconnect]: false,
+                },
+                url: "/_summarizer",
+            };
+            const fluidObject = await requestFluidObject(loaderRouter, request);
+            const summarizer = fluidObject.ISummarizer;
+            if (!summarizer) {
+                throw new UsageError("Fluid object does not implement ISummarizer");
+            }
+            return summarizer;
+        };
     }
 }
 /**