@fluidframework/container-runtime 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.2.0.0.245554

package/dist/dataStoreContext.js

@@ -12,8 +12,8 @@ const driver_utils_1 = require("@fluidframework/driver-utils");
 const runtime_definitions_1 = require("@fluidframework/runtime-definitions");
 const runtime_utils_1 = require("@fluidframework/runtime-utils");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
-const summary_1 = require("./summary");
-const gc_1 = require("./gc");
+const index_js_1 = require("./summary/index.js");
+const index_js_2 = require("./gc/index.js");
 function createAttributes(pkg, isRootDataStore) {
     const stringifiedPkg = JSON.stringify(pkg);
     return {
@@ -24,11 +24,12 @@ function createAttributes(pkg, isRootDataStore) {
 }
 function createAttributesBlob(pkg, isRootDataStore) {
     const attributes = createAttributes(pkg, isRootDataStore);
-    return new driver_utils_1.BlobTreeEntry(summary_1.dataStoreAttributesBlobName, JSON.stringify(attributes));
+    return new driver_utils_1.BlobTreeEntry(index_js_1.dataStoreAttributesBlobName, JSON.stringify(attributes));
 }
 exports.createAttributesBlob = createAttributesBlob;
 /**
  * Represents the context for the store. This context is passed to the store runtime.
+ * @internal
  */
 class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
     get packagePath() {
@@ -36,31 +37,31 @@ class FluidDataStoreContext extends client_utils_1.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;
@@ -69,7 +70,7 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
         return this._baseSnapshot;
     }
     get idCompressor() {
-        return this._containerRuntime.idCompressor;
+        return this.parentContext.idCompressor;
     }
     get disposed() {
         return this._disposed;
@@ -119,17 +120,19 @@ class FluidDataStoreContext extends client_utils_1.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.loadingGroupId = props.loadingGroupId;
         // URIs use slashes as delimiters. Handles use URIs.
         // Thus having slashes in types almost guarantees trouble down the road!
         (0, core_utils_1.assert)(!this.id.includes("/"), 0x13a /* Data store ID contains slash */);
         this._attachState =
-            this.containerRuntime.attachState !== container_definitions_1.AttachState.Detached && this.existing
-                ? this.containerRuntime.attachState
+            this.parentContext.attachState !== container_definitions_1.AttachState.Detached && this.existing
+                ? this.parentContext.attachState
                 : container_definitions_1.AttachState.Detached;
         const thisSummarizeInternal = async (fullTree, trackState, telemetryContext) => this.summarizeInternal(fullTree, trackState, telemetryContext);
         this.summarizerNode = props.createSummarizerNodeFn(thisSummarizeInternal, async (fullGC) => this.getGCDataInternal(fullGC));
@@ -146,7 +149,8 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
             },
         });
         this.thresholdOpsCounter = new telemetry_utils_1.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;
@@ -157,9 +161,9 @@ class FluidDataStoreContext extends client_utils_1.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();
             })
@@ -188,27 +192,26 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
     }
     async realize() {
         (0, core_utils_1.assert)(!this.detachedRuntimeCreation, 0x13d /* "Detached runtime creation on realize()" */);
-        if (!this.channelDeferred) {
-            this.channelDeferred = new core_utils_1.Deferred();
-            this.realizeCore(this.existing).catch((error) => {
+        if (!this.channelP) {
+            this.channelP = this.realizeCore(this.existing).catch((error) => {
                 const errorWrapped = telemetry_utils_1.DataProcessingError.wrapIfUnrecognized(error, "realizeFluidDataStoreContext");
                 errorWrapped.addTelemetryProperties((0, telemetry_utils_1.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) {
-        (0, core_utils_1.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) {
@@ -225,7 +228,9 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
         if (factory === undefined) {
             this.rejectDeferredRealize("Can't find factory for package", lastPkg, packages);
         }
-        return { factory, registry };
+        (0, core_utils_1.assert)(this.registry === undefined, 0x157 /* "datastore registry already attached" */);
+        this.registry = registry;
+        return factory;
     }
     async realizeCore(existing) {
         const details = await this.getInitialSnapshotDetails();
@@ -233,18 +238,18 @@ class FluidDataStoreContext extends client_utils_1.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);
-        (0, core_utils_1.assert)(this.registry === undefined, 0x13f /* "datastore context registry is already set" */);
-        this.registry = registry;
+        this.baseSnapshotSequenceNumber = details.sequenceNumber;
+        (0, core_utils_1.assert)(this.pkg === details.pkg, 0x13e /* "Unexpected package path" */);
+        const factory = await this.factoryFromPackagePath();
         const channel = await factory.instantiateDataStore(this, existing);
         (0, core_utils_1.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.
@@ -263,20 +268,14 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         this.channel.setConnectionState(connected, clientId);
     }
-    process(messageArg, local, localOpMetadata) {
-        const safeTelemetryProps = (0, telemetry_utils_1.extractSafePropertiesFromMessage)(messageArg);
+    process(message, local, localOpMetadata) {
+        const safeTelemetryProps = (0, telemetry_utils_1.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 telemetry_utils_1.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);
@@ -297,10 +296,10 @@ class FluidDataStoreContext extends client_utils_1.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.
@@ -316,19 +315,23 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const summarizeResult = await this.channel.summarize(fullTree, trackState, telemetryContext);
         // Wrap dds summaries in .channels subtree.
-        (0, summary_1.wrapSummaryInChannelsTree)(summarizeResult);
+        (0, index_js_1.wrapSummaryInChannelsTree)(summarizeResult);
         const pathPartsForChildren = [runtime_definitions_1.channelsTreeName];
         // Add data store's attributes to the summary.
         const { pkg } = await this.getInitialSnapshotDetails();
         const isRoot = await this.isRoot();
         const attributes = createAttributes(pkg, isRoot);
-        (0, runtime_utils_1.addBlobToSummary)(summarizeResult, summary_1.dataStoreAttributesBlobName, JSON.stringify(attributes));
+        (0, runtime_utils_1.addBlobToSummary)(summarizeResult, index_js_1.dataStoreAttributesBlobName, JSON.stringify(attributes));
         // If we are not referenced, mark the summary tree as unreferenced. Also, update unreferenced blob
         // size in the summary stats with the blobs size of this data store.
         if (!this.summarizerNode.isReferenced()) {
             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,
@@ -388,9 +391,11 @@ class FluidDataStoreContext extends client_utils_1.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.
@@ -398,11 +403,23 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
      */
     addedGCOutboundReference(srcHandle, outboundHandle) {
         // By default, skip this call since the ContainerRuntime will detect the outbound route directly.
-        if (this.mc.config.getBoolean(gc_1.detectOutboundRoutesViaDDSKey) === true) {
+        if (this.mc.config.getBoolean(index_js_2.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:
@@ -432,13 +449,9 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
     submitMessage(type, content, localOpMetadata) {
         this.verifyNotClosed("submitMessage");
         (0, core_utils_1.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.
@@ -468,7 +481,7 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
     submitSignal(type, content, targetClientId) {
         this.verifyNotClosed("submitSignal");
         (0, core_utils_1.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
@@ -476,54 +489,67 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
      */
     makeLocallyVisible() {
         (0, core_utils_1.assert)(this.channel !== undefined, 0x2cf /* "undefined channel on datastore context" */);
-        (0, core_utils_1.assert)(this.channel.visibilityState === runtime_definitions_1.VisibilityState.LocallyVisible, 0x590 /* Channel must be locally visible */);
         this.makeLocallyVisibleFn();
     }
-    bindRuntime(channel) {
-        if (this.channel) {
-            throw new Error("Runtime already bound");
-        }
-        try {
-            (0, core_utils_1.assert)(!this.detachedRuntimeCreation, 0x148 /* "Detached runtime creation on runtime bind" */);
-            (0, core_utils_1.assert)(this.channelDeferred !== undefined, 0x149 /* "Undefined channel deferral" */);
-            (0, core_utils_1.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");
         }
+        (0, core_utils_1.assert)(!this.detachedRuntimeCreation, 0x148 /* "Detached runtime creation on runtime bind" */);
+        (0, core_utils_1.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 !== container_definitions_1.AttachState.Attached) {
             return undefined;
         }
-        return this._containerRuntime.getAbsoluteUrl(relativeUrl);
+        return this.parentContext.getAbsoluteUrl(relativeUrl);
     }
     /**
      * @deprecated Sets the datastore as root, for aliasing purposes: #7948
@@ -539,20 +565,18 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
     async getBaseGCDetails() {
         return {};
     }
-    reSubmit(contents, localOpMetadata) {
+    reSubmit(type, contents, localOpMetadata) {
         (0, core_utils_1.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) {
@@ -577,13 +601,13 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
         if (checkTombstone && this.tombstoned) {
             const messageString = `Context is tombstoned! Call site [${callSite}]`;
             const error = new telemetry_utils_1.DataCorruptionError(messageString, safeTelemetryProps);
-            (0, gc_1.sendGCUnexpectedUsageEvent)(this.mc, {
+            (0, index_js_2.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;
             }
         }
@@ -594,7 +618,7 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
      * other clients that are up-to-date till seq# 100 may not have them yet.
      */
     identifyLocalChangeInSummarizer(eventName, type) {
-        if (this.clientDetails.type !== summary_1.summarizerClientType ||
+        if (this.clientDetails.type !== index_js_1.summarizerClientType ||
             this.localChangesTelemetryCount <= 0) {
             return;
         }
@@ -610,31 +634,42 @@ class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
         this.localChangesTelemetryCount--;
     }
     getCreateChildSummarizerNodeFn(id, createParam) {
-        return (summarizeInternal, getGCDataFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, 
-        // DDS will not create failure summaries
-        { throwOnFailure: true }, getGCDataFn);
+        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);
     }
 }
 exports.FluidDataStoreContext = FluidDataStoreContext;
 FluidDataStoreContext.pendingOpsCountThreshold = 1000;
+/** @internal */
 class RemoteFluidDataStoreContext extends FluidDataStoreContext {
     constructor(props) {
         super(props, true /* existing */, false /* isLocalDataStore */, () => {
             throw new Error("Already attached");
         });
         this.initialSnapshotDetailsP = new core_utils_1.LazyPromise(async () => {
-            let tree = this.initSnapshotValue;
+            // Sequence number of the snapshot.
+            let sequenceNumber;
+            if (this.snapshotFetchRequired) {
+                (0, core_utils_1.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[summary_1.dataStoreAttributesBlobName] !== undefined) {
+            if (!!tree && tree.blobs[index_js_1.dataStoreAttributesBlobName] !== undefined) {
                 // Need to get through snapshot and use that to populate extraBlobs
-                const attributes = await (0, driver_utils_1.readAndParse)(this.storage, tree.blobs[summary_1.dataStoreAttributesBlobName]);
+                const attributes = await (0, driver_utils_1.readAndParse)(this.storage, tree.blobs[index_js_1.dataStoreAttributesBlobName]);
                 let pkgFromSnapshot;
                 // Use the snapshotFormatVersion to determine how the pkg is encoded in the snapshot.
                 // For snapshotFormatVersion = "0.1" (1) or above, pkg is jsonified, otherwise it is just a string.
-                const formatVersion = (0, summary_1.getAttributesFormatVersion)(attributes);
+                const formatVersion = (0, index_js_1.getAttributesFormatVersion)(attributes);
                 if (formatVersion < 1) {
                     pkgFromSnapshot =
                         attributes.pkg.startsWith('["') && attributes.pkg.endsWith('"]')
@@ -651,37 +686,55 @@ class RemoteFluidDataStoreContext extends FluidDataStoreContext {
                  * roots in the document but they won't break.
                  */
                 isRootDataStore = attributes.isRootDataStore ?? true;
-                if ((0, summary_1.hasIsolatedChannels)(attributes)) {
+                if ((0, index_js_1.hasIsolatedChannels)(attributes)) {
                     tree = tree.trees[runtime_definitions_1.channelsTreeName];
                     (0, core_utils_1.assert)(tree !== undefined, 0x1fe /* "isolated channels subtree should exist in remote datastore snapshot" */);
                 }
             }
+            (0, core_utils_1.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");
     }
 }
 exports.RemoteFluidDataStoreContext = RemoteFluidDataStoreContext;
 /**
  * Base class for detached & attached context classes
+ * @internal
  */
 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 core_utils_1.LazyPromise(async () => {
             let snapshot = this.snapshotTree;
             let attributes;
@@ -689,8 +742,8 @@ class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
             if (snapshot !== undefined) {
                 // Get the dataStore attributes.
                 // Note: storage can be undefined in special case while detached.
-                attributes = await (0, summary_1.getFluidDataStoreAttributes)(this.storage, snapshot);
-                if ((0, summary_1.hasIsolatedChannels)(attributes)) {
+                attributes = await (0, index_js_1.getFluidDataStoreAttributes)(this.storage, snapshot);
+                if ((0, index_js_1.hasIsolatedChannels)(attributes)) {
                     snapshot = snapshot.trees[runtime_definitions_1.channelsTreeName];
                     (0, core_utils_1.assert)(snapshot !== undefined, 0x1ff /* "isolated channels subtree should exist in local datastore snapshot" */);
                 }
@@ -715,39 +768,73 @@ 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", () => {
-            (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Detached, 0x14d /* "Should move from detached to attaching" */);
-            this._attachState = container_definitions_1.AttachState.Attaching;
-        });
-        this.once("attached", () => {
-            (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attaching, 0x14e /* "Should move from attaching to attached" */);
-            this._attachState = container_definitions_1.AttachState.Attached;
-        });
+    setAttachState(attachState) {
+        switch (attachState) {
+            case container_definitions_1.AttachState.Attaching:
+                (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Detached, 0x14d /* "Should move from detached to attaching" */);
+                this._attachState = container_definitions_1.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 container_definitions_1.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 !== container_definitions_1.AttachState.Attached) {
+                    (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attaching, 0x14e /* "Should move from attaching to attached" */);
+                    this._attachState = container_definitions_1.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:
+                (0, core_utils_1.unreachableCase)(attachState, "unreached");
+        }
     }
-    generateAttachMessage() {
+    /**
+     * @see FluidDataStoreContext.getAttachData
+     */
+    getAttachData(includeGCData, telemetryContext) {
         (0, core_utils_1.assert)(this.channel !== undefined, 0x14f /* "There should be a channel when generating attach message" */);
         (0, core_utils_1.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.
-        (0, summary_1.wrapSummaryInChannelsTree)(summarizeResult);
+        (0, index_js_1.wrapSummaryInChannelsTree)(attachSummary);
         // Add data store's attributes to the summary.
         const attributes = createAttributes(this.pkg, this.isInMemoryRoot());
-        (0, runtime_utils_1.addBlobToSummary)(summarizeResult, summary_1.dataStoreAttributesBlobName, JSON.stringify(attributes));
-        // Attach message needs the summary in ITree format. Convert the ISummaryTree into an ITree.
-        const snapshot = (0, runtime_utils_1.convertSummaryTreeToITree)(summarizeResult.summary);
-        const message = {
-            id: this.id,
-            snapshot,
+        (0, runtime_utils_1.addBlobToSummary)(attachSummary, index_js_1.dataStoreAttributesBlobName, JSON.stringify(attributes));
+        if (includeGCData) {
+            const gcData = this.channel.getAttachGCData?.(telemetryContext);
+            if (gcData !== undefined) {
+                (0, runtime_utils_1.addBlobToSummary)(attachSummary, runtime_definitions_1.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;
@@ -761,7 +848,7 @@ class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
      */
     delete() {
         // TODO: GC:Validation - potentially prevent this from happening or asserting. Maybe throw here.
-        (0, gc_1.sendGCUnexpectedUsageEvent)(this.mc, {
+        (0, index_js_2.sendGCUnexpectedUsageEvent)(this.mc, {
             eventName: "GC_Deleted_DataStore_Unexpected_Delete",
             message: "Unexpected deletion of a local data store context",
             category: "error",
@@ -776,6 +863,7 @@ exports.LocalFluidDataStoreContextBase = LocalFluidDataStoreContextBase;
  * 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
  */
 class LocalFluidDataStoreContext extends LocalFluidDataStoreContextBase {
     constructor(props) {
@@ -793,29 +881,29 @@ class LocalDetachedFluidDataStoreContext extends LocalFluidDataStoreContextBase
     constructor(props) {
         super(props);
         this.detachedRuntimeCreation = true;
+        this.channelToDataStoreFn = props.channelToDataStoreFn;
     }
     async attachRuntime(registry, dataStoreChannel) {
         (0, core_utils_1.assert)(this.detachedRuntimeCreation, 0x154 /* "runtime creation is already attached" */);
         this.detachedRuntimeCreation = false;
-        (0, core_utils_1.assert)(this.channelDeferred === undefined, 0x155 /* "channel deferral is already set" */);
-        this.channelDeferred = new core_utils_1.Deferred();
-        const factory = registry.IFluidDataStoreFactory;
-        const entry = await this.factoryFromPackagePath(this.pkg);
-        (0, core_utils_1.assert)(entry.factory === factory, 0x156 /* "Unexpected factory for package path" */);
-        (0, core_utils_1.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();
-        }
+        (0, core_utils_1.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();
+            (0, core_utils_1.assert)(factory2 === factory, 0x156 /* "Unexpected factory for package path" */);
+            await super.bindRuntime(dataStoreChannel, false /* existing */);
+            (0, core_utils_1.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) {