@fluidframework/container-runtime 2.0.0-dev-rc.1.0.0.232845 → 2.0.0-dev-rc.2.0.0.246488

package/lib/{dataStoreContext.mjs → dataStoreContext.js}

@@ -2,15 +2,15 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { AttachState, } from "@fluidframework/container-definitions";
+import { AttachState } from "@fluidframework/container-definitions";
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
-import { assert, Deferred, LazyPromise } from "@fluidframework/core-utils";
+import { assert, LazyPromise, unreachableCase } from "@fluidframework/core-utils";
 import { BlobTreeEntry, readAndParse } from "@fluidframework/driver-utils";
-import { channelsTreeName, VisibilityState, } from "@fluidframework/runtime-definitions";
-import { addBlobToSummary, convertSummaryTreeToITree } from "@fluidframework/runtime-utils";
+import { channelsTreeName, gcDataBlobKey, } from "@fluidframework/runtime-definitions";
+import { addBlobToSummary } from "@fluidframework/runtime-utils";
 import { createChildMonitoringContext, DataCorruptionError, DataProcessingError, extractSafePropertiesFromMessage, generateStack, LoggingError, tagCodeArtifacts, ThresholdCounter, } from "@fluidframework/telemetry-utils";
-import { dataStoreAttributesBlobName, hasIsolatedChannels, wrapSummaryInChannelsTree, getAttributesFormatVersion, getFluidDataStoreAttributes, summarizerClientType, } from "./summary/index.mjs";
-import { detectOutboundRoutesViaDDSKey, sendGCUnexpectedUsageEvent } from "./gc/index.mjs";
+import { dataStoreAttributesBlobName, hasIsolatedChannels, wrapSummaryInChannelsTree, getAttributesFormatVersion, getFluidDataStoreAttributes, summarizerClientType, } from "./summary/index.js";
+import { detectOutboundRoutesViaDDSKey, sendGCUnexpectedUsageEvent } from "./gc/index.js";
 function createAttributes(pkg, isRootDataStore) {
     const stringifiedPkg = JSON.stringify(pkg);
     return {
@@ -25,6 +25,7 @@ export function createAttributesBlob(pkg, isRootDataStore) {
 }
 /**
  * Represents the context for the store. This context is passed to the store runtime.
+ * @internal
  */
 export class FluidDataStoreContext extends TypedEventEmitter {
     get packagePath() {
@@ -32,31 +33,31 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         return this.pkg;
     }
     get options() {
-        return this._containerRuntime.options;
+        return this.parentContext.options;
     }
     get clientId() {
-        return this._containerRuntime.clientId;
+        return this.parentContext.clientId;
     }
     get clientDetails() {
-        return this._containerRuntime.clientDetails;
+        return this.parentContext.clientDetails;
     }
     get logger() {
-        return this._containerRuntime.logger;
+        return this.parentContext.logger;
     }
     get deltaManager() {
-        return this._containerRuntime.deltaManager;
+        return this.parentContext.deltaManager;
     }
     get connected() {
-        return this._containerRuntime.connected;
+        return this.parentContext.connected;
     }
     get IFluidHandleContext() {
-        return this._containerRuntime.IFluidHandleContext;
+        return this.parentContext.IFluidHandleContext;
     }
     get containerRuntime() {
         return this._containerRuntime;
     }
     ensureNoDataModelChanges(callback) {
-        return this._containerRuntime.ensureNoDataModelChanges(callback);
+        return this.parentContext.ensureNoDataModelChanges(callback);
     }
     get isLoaded() {
         return this.loaded;
@@ -65,7 +66,7 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         return this._baseSnapshot;
     }
     get idCompressor() {
-        return this._containerRuntime.idCompressor;
+        return this.parentContext.idCompressor;
     }
     get disposed() {
         return this._disposed;
@@ -115,18 +116,19 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         this.loaded = false;
         this.pending = [];
         this._isInMemoryRoot = false;
-        this._containerRuntime = props.runtime;
+        this._containerRuntime = props.parentContext.containerRuntime;
+        this.parentContext = props.parentContext;
         this.id = props.id;
         this.storage = props.storage;
         this.scope = props.scope;
         this.pkg = props.pkg;
-        this.groupId = props.groupId;
+        this.loadingGroupId = props.loadingGroupId;
         // URIs use slashes as delimiters. Handles use URIs.
         // Thus having slashes in types almost guarantees trouble down the road!
         assert(!this.id.includes("/"), 0x13a /* Data store ID contains slash */);
         this._attachState =
-            this.containerRuntime.attachState !== AttachState.Detached && this.existing
-                ? this.containerRuntime.attachState
+            this.parentContext.attachState !== AttachState.Detached && this.existing
+                ? this.parentContext.attachState
                 : AttachState.Detached;
         const thisSummarizeInternal = async (fullTree, trackState, telemetryContext) => this.summarizeInternal(fullTree, trackState, telemetryContext);
         this.summarizerNode = props.createSummarizerNodeFn(thisSummarizeInternal, async (fullGC) => this.getGCDataInternal(fullGC));
@@ -143,7 +145,8 @@ export class FluidDataStoreContext extends TypedEventEmitter {
             },
         });
         this.thresholdOpsCounter = new ThresholdCounter(FluidDataStoreContext.pendingOpsCountThreshold, this.mc.logger);
-        this.throwOnTombstoneUsage = this._containerRuntime.gcThrowOnTombstoneUsage;
+        this.gcThrowOnTombstoneUsage = this.parentContext.gcThrowOnTombstoneUsage;
+        this.gcTombstoneEnforcementAllowed = this.parentContext.gcTombstoneEnforcementAllowed;
         // By default, a data store can log maximum 10 local changes telemetry in summarizer.
         this.localChangesTelemetryCount =
             this.mc.config.getNumber("Fluid.Telemetry.LocalChangesTelemetryCount") ?? 10;
@@ -154,9 +157,9 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         }
         this._disposed = true;
         // Dispose any pending runtime after it gets fulfilled
-        // Errors are logged where this.channelDeferred is consumed/generated (realizeCore(), bindRuntime())
-        if (this.channelDeferred) {
-            this.channelDeferred.promise
+        // Errors are logged where this.channelP is consumed/generated (realizeCore(), bindRuntime())
+        if (this.channelP) {
+            this.channelP
                 .then((runtime) => {
                 runtime.dispose();
             })
@@ -185,27 +188,26 @@ export class FluidDataStoreContext extends TypedEventEmitter {
     }
     async realize() {
         assert(!this.detachedRuntimeCreation, 0x13d /* "Detached runtime creation on realize()" */);
-        if (!this.channelDeferred) {
-            this.channelDeferred = new Deferred();
-            this.realizeCore(this.existing).catch((error) => {
+        if (!this.channelP) {
+            this.channelP = this.realizeCore(this.existing).catch((error) => {
                 const errorWrapped = DataProcessingError.wrapIfUnrecognized(error, "realizeFluidDataStoreContext");
                 errorWrapped.addTelemetryProperties(tagCodeArtifacts({
                     fullPackageName: this.pkg?.join("/"),
                     fluidDataStoreId: this.id,
                 }));
-                this.channelDeferred?.reject(errorWrapped);
                 this.mc.logger.sendErrorEvent({ eventName: "RealizeError" }, errorWrapped);
+                throw errorWrapped;
             });
         }
-        return this.channelDeferred.promise;
+        return this.channelP;
     }
-    async factoryFromPackagePath(packages) {
-        assert(this.pkg === packages, 0x13e /* "Unexpected package path" */);
+    async factoryFromPackagePath() {
+        const packages = this.pkg;
         if (packages === undefined) {
             this.rejectDeferredRealize("packages is undefined");
         }
         let entry;
-        let registry = this._containerRuntime.IFluidDataStoreRegistry;
+        let registry = this.parentContext.IFluidDataStoreRegistry;
         let lastPkg;
         for (const pkg of packages) {
             if (!registry) {
@@ -222,7 +224,9 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         if (factory === undefined) {
             this.rejectDeferredRealize("Can't find factory for package", lastPkg, packages);
         }
-        return { factory, registry };
+        assert(this.registry === undefined, 0x157 /* "datastore registry already attached" */);
+        this.registry = registry;
+        return factory;
     }
     async realizeCore(existing) {
         const details = await this.getInitialSnapshotDetails();
@@ -230,18 +234,18 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         // It is important that this be in sync with the pending ops, and also
         // that it is set here, before bindRuntime is called.
         this._baseSnapshot = details.snapshot;
-        const packages = details.pkg;
-        const { factory, registry } = await this.factoryFromPackagePath(packages);
-        assert(this.registry === undefined, 0x13f /* "datastore context registry is already set" */);
-        this.registry = registry;
+        this.baseSnapshotSequenceNumber = details.sequenceNumber;
+        assert(this.pkg === details.pkg, 0x13e /* "Unexpected package path" */);
+        const factory = await this.factoryFromPackagePath();
         const channel = await factory.instantiateDataStore(this, existing);
         assert(channel !== undefined, 0x140 /* "undefined channel on datastore context" */);
-        this.bindRuntime(channel);
+        await this.bindRuntime(channel, existing);
         // This data store may have been disposed before the channel is created during realization. If so,
         // dispose the channel now.
         if (this.disposed) {
             channel.dispose();
         }
+        return channel;
     }
     /**
      * Notifies this object about changes in the connection state.
@@ -260,20 +264,14 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         this.channel.setConnectionState(connected, clientId);
     }
-    process(messageArg, local, localOpMetadata) {
-        const safeTelemetryProps = extractSafePropertiesFromMessage(messageArg);
+    process(message, local, localOpMetadata) {
+        const safeTelemetryProps = extractSafePropertiesFromMessage(message);
         // On op process, tombstone error is logged in garbage collector. So, set "checkTombstone" to false when calling
         // "verifyNotClosed" which logs tombstone errors. Throw error if tombstoned and throwing on load is configured.
         this.verifyNotClosed("process", false /* checkTombstone */, safeTelemetryProps);
-        if (this.tombstoned && this.throwOnTombstoneUsage) {
+        if (this.tombstoned && this.gcThrowOnTombstoneUsage) {
             throw new DataCorruptionError("Context is tombstoned! Call site [process]", safeTelemetryProps);
         }
-        const innerContents = messageArg.contents;
-        const message = {
-            ...messageArg,
-            type: innerContents.type,
-            contents: innerContents.content,
-        };
         this.summarizerNode.recordChange(message);
         if (this.loaded) {
             return this.channel?.process(message, local, localOpMetadata);
@@ -294,10 +292,10 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         this.channel?.processSignal(message, local);
     }
     getQuorum() {
-        return this._containerRuntime.getQuorum();
+        return this.parentContext.getQuorum();
     }
     getAudience() {
-        return this._containerRuntime.getAudience();
+        return this.parentContext.getAudience();
     }
     /**
      * Returns a summary at the current sequence number.
@@ -326,6 +324,10 @@ export class FluidDataStoreContext extends TypedEventEmitter {
             summarizeResult.summary.unreferenced = true;
             summarizeResult.stats.unreferencedBlobSize = summarizeResult.stats.totalBlobSize;
         }
+        // Add loadingGroupId to the summary
+        if (this.loadingGroupId !== undefined) {
+            summarizeResult.summary.groupId = this.loadingGroupId;
+        }
         return {
             ...summarizeResult,
             id: this.id,
@@ -385,9 +387,11 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         }
     }
     /**
-     * @deprecated There is no replacement for this, its functionality is no longer needed.
+     * @deprecated There is no replacement for this, its functionality is no longer needed at this layer.
      * It will be removed in a future release, sometime after 2.0.0-internal.8.0.0
      *
+     * Similar capability is exposed with from/to string paths instead of handles via @see addedGCOutboundRoute
+     *
      * 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.
@@ -397,9 +401,21 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         // By default, skip this call since the ContainerRuntime will detect the outbound route directly.
         if (this.mc.config.getBoolean(detectOutboundRoutesViaDDSKey) === true) {
             // Note: The ContainerRuntime code will check this same setting to avoid double counting.
-            this._containerRuntime.addedGCOutboundReference(srcHandle, outboundHandle);
+            this.parentContext.addedGCOutboundReference?.(srcHandle, outboundHandle);
         }
     }
+    /**
+     * (Same as @see addedGCOutboundReference, but with string paths instead of handles)
+     *
+     * 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 fromPath - The absolute path of the node that added the reference.
+     * @param toPath - The absolute path of the outbound node that is referenced.
+     */
+    addedGCOutboundRoute(fromPath, toPath) {
+        this.parentContext.addedGCOutboundReference?.({ absolutePath: fromPath }, { absolutePath: toPath });
+    }
     /**
      * Updates the used routes of the channel and its child contexts. The channel must be loaded before calling this.
      * It is called in these two scenarios:
@@ -429,13 +445,9 @@ export class FluidDataStoreContext extends TypedEventEmitter {
     submitMessage(type, content, localOpMetadata) {
         this.verifyNotClosed("submitMessage");
         assert(!!this.channel, 0x146 /* "Channel must exist when submitting message" */);
-        const fluidDataStoreContent = {
-            content,
-            type,
-        };
         // Summarizer clients should not submit messages.
         this.identifyLocalChangeInSummarizer("DataStoreMessageSubmittedInSummarizer", type);
-        this._containerRuntime.submitDataStoreOp(this.id, fluidDataStoreContent, localOpMetadata);
+        this.parentContext.submitMessage(type, content, localOpMetadata);
     }
     /**
      * This is called from a SharedSummaryBlock that does not generate ops but only wants to be part of the summary.
@@ -465,7 +477,7 @@ export class FluidDataStoreContext extends TypedEventEmitter {
     submitSignal(type, content, targetClientId) {
         this.verifyNotClosed("submitSignal");
         assert(!!this.channel, 0x147 /* "Channel must exist on submitting signal" */);
-        return this._containerRuntime.submitDataStoreSignal(this.id, type, content, targetClientId);
+        return this.parentContext.submitSignal(type, content, targetClientId);
     }
     /**
      * This is called by the data store channel when it becomes locally visible indicating that it is ready to become
@@ -473,54 +485,67 @@ export class FluidDataStoreContext extends TypedEventEmitter {
      */
     makeLocallyVisible() {
         assert(this.channel !== undefined, 0x2cf /* "undefined channel on datastore context" */);
-        assert(this.channel.visibilityState === VisibilityState.LocallyVisible, 0x590 /* Channel must be locally visible */);
         this.makeLocallyVisibleFn();
     }
-    bindRuntime(channel) {
-        if (this.channel) {
-            throw new Error("Runtime already bound");
-        }
-        try {
-            assert(!this.detachedRuntimeCreation, 0x148 /* "Detached runtime creation on runtime bind" */);
-            assert(this.channelDeferred !== undefined, 0x149 /* "Undefined channel deferral" */);
-            assert(this.pkg !== undefined, 0x14a /* "Undefined package path" */);
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const pending = this.pending;
-            // Apply all pending ops
-            for (const op of pending) {
+    processPendingOps(channel) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const pending = this.pending;
+        // Apply all pending ops
+        for (const op of pending) {
+            // Only process ops whose seq number is greater than snapshot sequence number from which it loaded.
+            const seqNumber = this.baseSnapshotSequenceNumber ?? -1;
+            if (op.sequenceNumber > seqNumber) {
                 channel.process(op, false, undefined /* localOpMetadata */);
             }
-            this.thresholdOpsCounter.send("ProcessPendingOps", pending.length);
-            this.pending = undefined;
-            // And now mark the runtime active
-            this.loaded = true;
-            this.channel = channel;
-            // Freeze the package path to ensure that someone doesn't modify it when it is
-            // returned in packagePath().
-            Object.freeze(this.pkg);
-            /**
-             * Update the used routes of the channel. If GC has run before this data store was realized, we will have
-             * the used routes saved. So, this will ensure that all the child contexts have up-to-date used routes as
-             * per the last time GC was run.
-             * Also, this data store may have been realized during summarize. In that case, the child contexts need to
-             * have their used routes updated to determine if its needs to summarize again and to add it to the summary.
-             */
-            this.updateChannelUsedRoutes();
-            // And notify the pending promise it is now available
-            this.channelDeferred.resolve(this.channel);
         }
-        catch (error) {
-            this.channelDeferred?.reject(error);
-            this.mc.logger.sendErrorEvent({
-                eventName: "BindRuntimeError",
-            }, error);
+        this.pending = undefined;
+        this.thresholdOpsCounter.send("ProcessPendingOps", pending.length);
+    }
+    completeBindingRuntime(channel) {
+        // And now mark the runtime active
+        this.loaded = true;
+        this.channel = channel;
+        // Channel does not know when it's "live" (as in - starts to receive events in the system)
+        // It may read current state of the system when channel was created, but it was not getting any updates
+        // through creation process and could have missed events. So update it on current state.
+        // Once this.loaded is set (above), it will stat receiving events.
+        channel.setConnectionState(this.connected, this.clientId);
+        // Freeze the package path to ensure that someone doesn't modify it when it is
+        // returned in packagePath().
+        Object.freeze(this.pkg);
+        /**
+         * Update the used routes of the channel. If GC has run before this data store was realized, we will have
+         * the used routes saved. So, this will ensure that all the child contexts have up-to-date used routes as
+         * per the last time GC was run.
+         * Also, this data store may have been realized during summarize. In that case, the child contexts need to
+         * have their used routes updated to determine if its needs to summarize again and to add it to the summary.
+         */
+        this.updateChannelUsedRoutes();
+    }
+    async bindRuntime(channel, existing) {
+        if (this.channel) {
+            throw new Error("Runtime already bound");
         }
+        assert(!this.detachedRuntimeCreation, 0x148 /* "Detached runtime creation on runtime bind" */);
+        assert(this.pkg !== undefined, 0x14a /* "Undefined package path" */);
+        if (!existing) {
+            // Execute data store's entry point to make sure that for a local (aka detached from container) data store, the
+            // entryPoint initialization function is called before the data store gets attached and potentially connected to
+            // the delta stream, so it gets a chance to do things while the data store is still "purely local".
+            // This preserves the behavior from before we introduced entryPoints, where the instantiateDataStore method
+            // of data store factories tends to construct the data object (at least kick off an async method that returns
+            // it); that code moved to the entryPoint initialization function, so we want to ensure it still executes
+            // before the data store is attached.
+            await channel.entryPoint.get();
+        }
+        this.processPendingOps(channel);
+        this.completeBindingRuntime(channel);
     }
     async getAbsoluteUrl(relativeUrl) {
         if (this.attachState !== AttachState.Attached) {
             return undefined;
         }
-        return this._containerRuntime.getAbsoluteUrl(relativeUrl);
+        return this.parentContext.getAbsoluteUrl(relativeUrl);
     }
     /**
      * @deprecated Sets the datastore as root, for aliasing purposes: #7948
@@ -536,20 +561,18 @@ export class FluidDataStoreContext extends TypedEventEmitter {
     async getBaseGCDetails() {
         return {};
     }
-    reSubmit(contents, localOpMetadata) {
+    reSubmit(type, contents, localOpMetadata) {
         assert(!!this.channel, 0x14b /* "Channel must exist when resubmitting ops" */);
-        const innerContents = contents;
-        this.channel.reSubmit(innerContents.type, innerContents.content, localOpMetadata);
+        this.channel.reSubmit(type, contents, localOpMetadata);
     }
-    rollback(contents, localOpMetadata) {
+    rollback(type, contents, localOpMetadata) {
         if (!this.channel) {
             throw new Error("Channel must exist when rolling back ops");
         }
         if (!this.channel.rollback) {
             throw new Error("Channel doesn't support rollback");
         }
-        const innerContents = contents;
-        this.channel.rollback(innerContents.type, innerContents.content, localOpMetadata);
+        this.channel.rollback(type, contents, localOpMetadata);
     }
     async applyStashedOp(contents) {
         if (!this.channel) {
@@ -576,11 +599,11 @@ export class FluidDataStoreContext extends TypedEventEmitter {
             const error = new DataCorruptionError(messageString, safeTelemetryProps);
             sendGCUnexpectedUsageEvent(this.mc, {
                 eventName: "GC_Tombstone_DataStore_Changed",
-                category: this.throwOnTombstoneUsage ? "error" : "generic",
-                gcTombstoneEnforcementAllowed: this._containerRuntime.gcTombstoneEnforcementAllowed,
+                category: this.gcThrowOnTombstoneUsage ? "error" : "generic",
+                gcTombstoneEnforcementAllowed: this.gcTombstoneEnforcementAllowed,
                 callSite,
             }, this.pkg, error);
-            if (this.throwOnTombstoneUsage) {
+            if (this.gcThrowOnTombstoneUsage) {
                 throw error;
             }
         }
@@ -609,18 +632,31 @@ export class FluidDataStoreContext extends TypedEventEmitter {
     getCreateChildSummarizerNodeFn(id, createParam) {
         return (summarizeInternal, getGCDataFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined /* config */, getGCDataFn);
     }
+    deleteChildSummarizerNode(id) {
+        this.summarizerNode.deleteChild(id);
+    }
     async uploadBlob(blob, signal) {
-        return this.containerRuntime.uploadBlob(blob, signal);
+        return this.parentContext.uploadBlob(blob, signal);
     }
 }
 FluidDataStoreContext.pendingOpsCountThreshold = 1000;
+/** @internal */
 export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
     constructor(props) {
         super(props, true /* existing */, false /* isLocalDataStore */, () => {
             throw new Error("Already attached");
         });
         this.initialSnapshotDetailsP = new LazyPromise(async () => {
-            let tree = this.initSnapshotValue;
+            // Sequence number of the snapshot.
+            let sequenceNumber;
+            if (this.snapshotFetchRequired) {
+                assert(this.loadingGroupId !== undefined, 0x8f5 /* groupId should be present to fetch snapshot */);
+                const snapshot = await this.runtime.getSnapshotForLoadingGroupId([this.loadingGroupId], [this.id]);
+                this._baseSnapshot = snapshot.snapshotTree;
+                sequenceNumber = snapshot.sequenceNumber;
+                this.snapshotFetchRequired = false;
+            }
+            let tree = this.baseSnapshot;
             let isRootDataStore = true;
             if (!!tree && tree.blobs[dataStoreAttributesBlobName] !== undefined) {
                 // Need to get through snapshot and use that to populate extraBlobs
@@ -650,31 +686,49 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
                     assert(tree !== undefined, 0x1fe /* "isolated channels subtree should exist in remote datastore snapshot" */);
                 }
             }
+            assert(this.pkg !== undefined, 0x8f6 /* The datastore context package should be defined */);
             return {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 pkg: this.pkg,
                 isRootDataStore,
                 snapshot: tree,
+                sequenceNumber,
             };
         });
-        this.initSnapshotValue = props.snapshotTree;
+        this._baseSnapshot = props.snapshotTree;
+        this.snapshotFetchRequired = !!props.snapshotTree?.omitted;
+        this.runtime = props.parentContext.containerRuntime;
         if (props.snapshotTree !== undefined) {
             this.summarizerNode.updateBaseSummaryState(props.snapshotTree);
         }
     }
+    /*
+    This API should not be called for RemoteFluidDataStoreContext. But here is one scenario where it's not the case:
+    The scenario (hit by stashedOps.spec.ts, "resends attach op" UT is the following (as far as I understand):
+    1. data store is being attached in attached container
+    2. container state is serialized (stashed ops feature)
+    3. new container instance is rehydrated (from stashed ops)
+        - As result, we create RemoteFluidDataStoreContext for this data store that is actually in "attaching" state (as of # 2).
+          But its state is set to attached when loading container from stashed ops
+    4. attach op for this data store is processed - setAttachState() is called.
+    */
+    setAttachState(attachState) { }
     async getInitialSnapshotDetails() {
         return this.initialSnapshotDetailsP;
     }
-    generateAttachMessage() {
+    /**
+     * @see FluidDataStoreContext.getAttachData
+     */
+    getAttachData(includeGCData) {
         throw new Error("Cannot attach remote store");
     }
 }
 /**
  * Base class for detached & attached context classes
+ * @internal
  */
 export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
     constructor(props) {
-        super(props, props.snapshotTree !== undefined ? true : false /* existing */, true /* isLocalDataStore */, props.makeLocallyVisibleFn);
+        super(props, props.snapshotTree !== undefined /* existing */, true /* isLocalDataStore */, props.makeLocallyVisibleFn);
         this.initialSnapshotDetailsP = new LazyPromise(async () => {
             let snapshot = this.snapshotTree;
             let attributes;
@@ -708,39 +762,73 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
         // Summarizer client should not create local data stores.
         this.identifyLocalChangeInSummarizer("DataStoreCreatedInSummarizer");
         this.snapshotTree = props.snapshotTree;
-        if (props.isRootDataStore === true) {
-            this.setInMemoryRoot();
-        }
         this.createProps = props.createProps;
-        this.attachListeners();
     }
-    attachListeners() {
-        this.once("attaching", () => {
-            assert(this.attachState === AttachState.Detached, 0x14d /* "Should move from detached to attaching" */);
-            this._attachState = AttachState.Attaching;
-        });
-        this.once("attached", () => {
-            assert(this.attachState === AttachState.Attaching, 0x14e /* "Should move from attaching to attached" */);
-            this._attachState = AttachState.Attached;
-        });
+    setAttachState(attachState) {
+        switch (attachState) {
+            case AttachState.Attaching:
+                assert(this.attachState === AttachState.Detached, 0x14d /* "Should move from detached to attaching" */);
+                this._attachState = AttachState.Attaching;
+                if (this.channel?.setAttachState) {
+                    this.channel.setAttachState(attachState);
+                }
+                else if (this.channel) {
+                    // back-compat! To be removed in the future
+                    // Added in "2.0.0-rc.2.0.0" timeframe.
+                    this.emit("attaching");
+                }
+                break;
+            case AttachState.Attached:
+                // We can get called into here twice, as result of both container and data store being attached, if
+                // those processes overlapped, for example, in a flow like that one:
+                // 1. Container attach started
+                // 2. data store attachment started
+                // 3. container attached
+                // 4. data store attached.
+                if (this.attachState !== AttachState.Attached) {
+                    assert(this.attachState === AttachState.Attaching, 0x14e /* "Should move from attaching to attached" */);
+                    this._attachState = AttachState.Attached;
+                    this.channel?.setAttachState?.(attachState);
+                    if (this.channel?.setAttachState) {
+                        this.channel.setAttachState(attachState);
+                    }
+                    else if (this.channel) {
+                        // back-compat! To be removed in the future
+                        // Added in "2.0.0-rc.2.0.0" timeframe.
+                        this.emit("attached");
+                    }
+                }
+                break;
+            default:
+                unreachableCase(attachState, "unreached");
+        }
     }
-    generateAttachMessage() {
+    /**
+     * @see FluidDataStoreContext.getAttachData
+     */
+    getAttachData(includeGCData, telemetryContext) {
         assert(this.channel !== undefined, 0x14f /* "There should be a channel when generating attach message" */);
         assert(this.pkg !== undefined, 0x150 /* "pkg should be available in local data store context" */);
-        const summarizeResult = this.channel.getAttachSummary();
+        const attachSummary = this.channel.getAttachSummary(telemetryContext);
         // Wrap dds summaries in .channels subtree.
-        wrapSummaryInChannelsTree(summarizeResult);
+        wrapSummaryInChannelsTree(attachSummary);
         // Add data store's attributes to the summary.
         const attributes = createAttributes(this.pkg, this.isInMemoryRoot());
-        addBlobToSummary(summarizeResult, dataStoreAttributesBlobName, JSON.stringify(attributes));
-        // Attach message needs the summary in ITree format. Convert the ISummaryTree into an ITree.
-        const snapshot = convertSummaryTreeToITree(summarizeResult.summary);
-        const message = {
-            id: this.id,
-            snapshot,
+        addBlobToSummary(attachSummary, dataStoreAttributesBlobName, JSON.stringify(attributes));
+        if (includeGCData) {
+            const gcData = this.channel.getAttachGCData?.(telemetryContext);
+            if (gcData !== undefined) {
+                addBlobToSummary(attachSummary, gcDataBlobKey, JSON.stringify(gcData));
+            }
+        }
+        // Add loadingGroupId to the summary
+        if (this.loadingGroupId !== undefined) {
+            attachSummary.summary.groupId = this.loadingGroupId;
+        }
+        return {
+            attachSummary,
             type: this.pkg[this.pkg.length - 1],
         };
-        return message;
     }
     async getInitialSnapshotDetails() {
         return this.initialSnapshotDetailsP;
@@ -768,6 +856,7 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
  * Various workflows (snapshot creation, requests) result in .realize() being called
  * on context, resulting in instantiation and attachment of runtime.
  * Runtime is created using data store factory that is associated with this context.
+ * @internal
  */
 export class LocalFluidDataStoreContext extends LocalFluidDataStoreContextBase {
     constructor(props) {
@@ -784,29 +873,29 @@ export class LocalDetachedFluidDataStoreContext extends LocalFluidDataStoreConte
     constructor(props) {
         super(props);
         this.detachedRuntimeCreation = true;
+        this.channelToDataStoreFn = props.channelToDataStoreFn;
     }
     async attachRuntime(registry, dataStoreChannel) {
         assert(this.detachedRuntimeCreation, 0x154 /* "runtime creation is already attached" */);
         this.detachedRuntimeCreation = false;
-        assert(this.channelDeferred === undefined, 0x155 /* "channel deferral is already set" */);
-        this.channelDeferred = new Deferred();
-        const factory = registry.IFluidDataStoreFactory;
-        const entry = await this.factoryFromPackagePath(this.pkg);
-        assert(entry.factory === factory, 0x156 /* "Unexpected factory for package path" */);
-        assert(this.registry === undefined, 0x157 /* "datastore registry already attached" */);
-        this.registry = entry.registry;
-        super.bindRuntime(dataStoreChannel);
-        // Load the handle to the data store's entryPoint to make sure that for a detached data store, the entryPoint
-        // initialization function is called before the data store gets attached and potentially connected to the
-        // delta stream, so it gets a chance to do things while the data store is still "purely local".
-        // This preserves the behavior from before we introduced entryPoints, where the instantiateDataStore method
-        // of data store factories tends to construct the data object (at least kick off an async method that returns
-        // it); that code moved to the entryPoint initialization function, so we want to ensure it still executes
-        // before the data store is attached.
-        await dataStoreChannel.entryPoint.get();
-        if (await this.isRoot()) {
-            dataStoreChannel.makeVisibleAndAttachGraph();
-        }
+        assert(this.channelP === undefined, 0x155 /* "channel deferral is already set" */);
+        this.channelP = Promise.resolve()
+            .then(async () => {
+            const factory = registry.IFluidDataStoreFactory;
+            const factory2 = await this.factoryFromPackagePath();
+            assert(factory2 === factory, 0x156 /* "Unexpected factory for package path" */);
+            await super.bindRuntime(dataStoreChannel, false /* existing */);
+            assert(!(await this.isRoot()), 0x8f7 /* there are no more createRootDataStore() kind of APIs! */);
+            return dataStoreChannel;
+        })
+            .catch((error) => {
+            this.mc.logger.sendErrorEvent({ eventName: "AttachRuntimeError" }, error);
+            // The following two lines result in same exception thrown.
+            // But we need to ensure that this.channelDeferred.promise is "observed", as otherwise
+            // out UT reports unhandled exception
+            throw error;
+        });
+        return this.channelToDataStoreFn(await this.channelP);
     }
     async getInitialSnapshotDetails() {
         if (this.detachedRuntimeCreation) {
@@ -815,4 +904,4 @@ export class LocalDetachedFluidDataStoreContext extends LocalFluidDataStoreConte
         return super.getInitialSnapshotDetails();
     }
 }
-//# sourceMappingURL=dataStoreContext.mjs.map
+//# sourceMappingURL=dataStoreContext.js.map