@fluidframework/datastore 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/dist/{dataStoreRuntime.js → dataStoreRuntime.cjs}

@@ -5,58 +5,129 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mixinSummaryHandler = exports.mixinRequestHandler = exports.FluidDataStoreRuntime = exports.DataStoreMessageType = void 0;
-const container_definitions_1 = require("@fluidframework/container-definitions");
-const container_utils_1 = require("@fluidframework/container-utils");
-const common_utils_1 = require("@fluidframework/common-utils");
+const client_utils_1 = require("@fluid-internal/client-utils");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
+const core_utils_1 = require("@fluidframework/core-utils");
+const container_definitions_1 = require("@fluidframework/container-definitions");
 const driver_utils_1 = require("@fluidframework/driver-utils");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const runtime_definitions_1 = require("@fluidframework/runtime-definitions");
 const runtime_utils_1 = require("@fluidframework/runtime-utils");
-const garbage_collector_1 = require("@fluidframework/garbage-collector");
 const uuid_1 = require("uuid");
-const channelContext_1 = require("./channelContext");
-const localChannelContext_1 = require("./localChannelContext");
-const remoteChannelContext_1 = require("./remoteChannelContext");
+const channelContext_1 = require("./channelContext.cjs");
+const localChannelContext_1 = require("./localChannelContext.cjs");
+const remoteChannelContext_1 = require("./remoteChannelContext.cjs");
+const fluidHandle_1 = require("./fluidHandle.cjs");
+/**
+ * @alpha
+ */
 var DataStoreMessageType;
 (function (DataStoreMessageType) {
     // Creates a new channel
     DataStoreMessageType["Attach"] = "attach";
     DataStoreMessageType["ChannelOp"] = "op";
-})(DataStoreMessageType = exports.DataStoreMessageType || (exports.DataStoreMessageType = {}));
+})(DataStoreMessageType || (exports.DataStoreMessageType = DataStoreMessageType = {}));
 /**
  * Base data store class
+ * @alpha
  */
-class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
-    constructor(dataStoreContext, sharedObjectRegistry, existing) {
+class FluidDataStoreRuntime extends client_utils_1.TypedEventEmitter {
+    get connected() {
+        return this.dataStoreContext.connected;
+    }
+    get clientId() {
+        return this.dataStoreContext.clientId;
+    }
+    get clientDetails() {
+        return this.dataStoreContext.clientDetails;
+    }
+    get isAttached() {
+        return this.attachState !== container_definitions_1.AttachState.Detached;
+    }
+    get attachState() {
+        return this._attachState;
+    }
+    get absolutePath() {
+        return (0, runtime_utils_1.generateHandleContextPath)(this.id, this.routeContext);
+    }
+    get routeContext() {
+        return this.dataStoreContext.IFluidHandleContext;
+    }
+    get idCompressor() {
+        return this.dataStoreContext.idCompressor;
+    }
+    get IFluidHandleContext() {
+        return this;
+    }
+    get rootRoutingContext() {
+        return this;
+    }
+    get channelsRoutingContext() {
+        return this;
+    }
+    get objectsRoutingContext() {
+        return this;
+    }
+    get disposed() {
+        return this._disposed;
+    }
+    get logger() {
+        return this.mc.logger;
+    }
+    /**
+     * Invokes the given callback and expects that no ops are submitted
+     * until execution finishes. If an op is submitted, an error will be raised.
+     *
+     * Can be disabled by feature gate `Fluid.ContainerRuntime.DisableOpReentryCheck`
+     *
+     * @param callback - the callback to be invoked
+     */
+    ensureNoDataModelChanges(callback) {
+        // back-compat ADO:2309
+        return this.dataStoreContext.ensureNoDataModelChanges === undefined
+            ? callback()
+            : this.dataStoreContext.ensureNoDataModelChanges(callback);
+    }
+    /**
+     * Create an instance of a DataStore runtime.
+     *
+     * @param dataStoreContext - Context object for the runtime.
+     * @param sharedObjectRegistry - The registry of shared objects that this data store will be able to instantiate.
+     * @param existing - Pass 'true' if loading this datastore from an existing file; pass 'false' otherwise.
+     * @param provideEntryPoint - Function to initialize the entryPoint object for the data store runtime. The
+     * handle to this data store runtime will point to the object returned by this function. If this function is not
+     * provided, the handle will be left undefined. This is here so we can start making handles a first-class citizen
+     * and the primary way of interacting with some Fluid objects, and should be used if possible.
+     */
+    constructor(dataStoreContext, sharedObjectRegistry, existing, provideEntryPoint) {
         super();
         this.dataStoreContext = dataStoreContext;
         this.sharedObjectRegistry = sharedObjectRegistry;
         this._disposed = false;
         this.contexts = new Map();
-        this.contextsDeferred = new Map();
-        this.pendingAttach = new Map();
-        this.deferredAttached = new common_utils_1.Deferred();
+        this.pendingAttach = new Set();
+        this.deferredAttached = new core_utils_1.Deferred();
         this.localChannelContextQueue = new Map();
         this.notBoundedChannelContextSet = new Set();
         // A list of handles that are bound when the data store is not visible. We have to make them visible when the data
         // store becomes visible.
         this.pendingHandlesToMakeVisible = new Set();
-        (0, common_utils_1.assert)(!dataStoreContext.id.includes("/"), 0x30e /* Id cannot contain slashes. DataStoreContext should have validated this. */);
-        this.logger = telemetry_utils_1.ChildLogger.create(dataStoreContext.logger, "FluidDataStoreRuntime", { all: { dataStoreId: (0, uuid_1.v4)() } });
+        (0, core_utils_1.assert)(!dataStoreContext.id.includes("/"), 0x30e /* Id cannot contain slashes. DataStoreContext should have validated this. */);
+        this.mc = (0, telemetry_utils_1.createChildMonitoringContext)({
+            logger: dataStoreContext.logger,
+            namespace: "FluidDataStoreRuntime",
+            properties: {
+                all: { dataStoreId: (0, uuid_1.v4)() },
+            },
+        });
         this.id = dataStoreContext.id;
         this.options = dataStoreContext.options;
         this.deltaManager = dataStoreContext.deltaManager;
         this.quorum = dataStoreContext.getQuorum();
         this.audience = dataStoreContext.getAudience();
         const tree = dataStoreContext.baseSnapshot;
-        this.channelsBaseGCDetails = new common_utils_1.LazyPromise(async () => {
-            var _a, _b, _c;
-            const baseGCDetails = await ((_c = (_b = (_a = this.dataStoreContext).getBaseGCDetails) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : this.dataStoreContext.getInitialGCSummaryDetails());
-            return (0, garbage_collector_1.unpackChildNodesGCDetails)(baseGCDetails);
-        });
         // Must always receive the data store type inside of the attributes
-        if ((tree === null || tree === void 0 ? void 0 : tree.trees) !== undefined) {
+        if (tree?.trees !== undefined) {
             Object.keys(tree.trees).forEach((path) => {
                 // Issue #4414
                 if (path === "_search") {
@@ -80,29 +151,31 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
                     }
                 }
                 else {
-                    channelContext = new remoteChannelContext_1.RemoteChannelContext(this, dataStoreContext, dataStoreContext.storage, (content, localOpMetadata) => this.submitChannelOp(path, content, localOpMetadata), (address) => this.setChannelDirty(address), (srcHandle, outboundHandle) => this.addedGCOutboundReference(srcHandle, outboundHandle), path, tree.trees[path], this.sharedObjectRegistry, undefined /* extraBlobs */, this.dataStoreContext.getCreateChildSummarizerNodeFn(path, { type: runtime_definitions_1.CreateSummarizerNodeSource.FromSummary }), async () => this.getChannelBaseGCDetails(path));
+                    channelContext = new remoteChannelContext_1.RemoteChannelContext(this, dataStoreContext, dataStoreContext.storage, (content, localOpMetadata) => this.submitChannelOp(path, content, localOpMetadata), (address) => this.setChannelDirty(address), (srcHandle, outboundHandle) => this.addedGCOutboundReference(srcHandle, outboundHandle), path, tree.trees[path], this.sharedObjectRegistry, undefined /* extraBlobs */, this.dataStoreContext.getCreateChildSummarizerNodeFn(path, {
+                        type: runtime_definitions_1.CreateSummarizerNodeSource.FromSummary,
+                    }));
                 }
-                const deferred = new common_utils_1.Deferred();
-                deferred.resolve(channelContext);
                 this.contexts.set(path, channelContext);
-                this.contextsDeferred.set(path, deferred);
             });
         }
+        this.entryPoint = new fluidHandle_1.FluidObjectHandle(new core_utils_1.LazyPromise(async () => provideEntryPoint(this)), "", this.objectsRoutingContext);
         this.attachListener();
-        // If exists on storage or loaded from a snapshot, it should already be bound.
-        this.bindState = existing ? container_definitions_1.BindState.Bound : container_definitions_1.BindState.NotBound;
         this._attachState = dataStoreContext.attachState;
         /**
          * If existing flag is false, this is a new data store and is not visible. The existing flag can be true in two
          * conditions:
+         *
          * 1. It's a local data store that is created when a detached container is rehydrated. In this case, the data
-         *    store is locally visible because the snapshot it is loaded from contains locally visible data stores only.
+         * store is locally visible because the snapshot it is loaded from contains locally visible data stores only.
+         *
          * 2. It's a remote data store that is created when an attached container is loaded is loaded from snapshot or
-         *    when an attach op comes in. In both these cases, the data store is already globally visible.
+         * when an attach op comes in. In both these cases, the data store is already globally visible.
          */
         if (existing) {
-            this.visibilityState = dataStoreContext.attachState === container_definitions_1.AttachState.Detached
-                ? runtime_definitions_1.VisibilityState.LocallyVisible : runtime_definitions_1.VisibilityState.GloballyVisible;
+            this.visibilityState =
+                dataStoreContext.attachState === container_definitions_1.AttachState.Detached
+                    ? runtime_definitions_1.VisibilityState.LocallyVisible
+                    : runtime_definitions_1.VisibilityState.GloballyVisible;
         }
         else {
             this.visibilityState = runtime_definitions_1.VisibilityState.NotVisible;
@@ -111,43 +184,10 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
         if (existing) {
             this.deferredAttached.resolve();
         }
+        // By default, a data store can log maximum 10 local changes telemetry in summarizer.
+        this.localChangesTelemetryCount =
+            this.mc.config.getNumber("Fluid.Telemetry.LocalChangesTelemetryCount") ?? 10;
     }
-    /**
-     * Loads the data store runtime
-     * @param context - The data store context
-     * @param sharedObjectRegistry - The registry of shared objects used by this data store
-     * @param existing - If loading from an existing file.
-     */
-    static load(context, sharedObjectRegistry, existing) {
-        return new FluidDataStoreRuntime(context, sharedObjectRegistry, existing);
-    }
-    get IFluidRouter() { return this; }
-    get connected() {
-        return this.dataStoreContext.connected;
-    }
-    get clientId() {
-        return this.dataStoreContext.clientId;
-    }
-    get clientDetails() {
-        return this.dataStoreContext.clientDetails;
-    }
-    get isAttached() {
-        return this.attachState !== container_definitions_1.AttachState.Detached;
-    }
-    get attachState() {
-        return this._attachState;
-    }
-    get absolutePath() {
-        return (0, runtime_utils_1.generateHandleContextPath)(this.id, this.routeContext);
-    }
-    get routeContext() {
-        return this.dataStoreContext.IFluidHandleContext;
-    }
-    get IFluidHandleContext() { return this; }
-    get rootRoutingContext() { return this; }
-    get channelsRoutingContext() { return this; }
-    get objectsRoutingContext() { return this; }
-    get disposed() { return this._disposed; }
     dispose() {
         if (this._disposed) {
             return;
@@ -164,18 +204,17 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
             const parser = runtime_utils_1.RequestParser.create(request);
             const id = parser.pathParts[0];
             if (id === "_channels" || id === "_custom") {
-                return this.request(parser.createSubRequest(1));
+                return await this.request(parser.createSubRequest(1));
             }
             // Check for a data type reference first
-            if (this.contextsDeferred.has(id) && parser.isLeaf(1)) {
+            const context = this.contexts.get(id);
+            if (context !== undefined && parser.isLeaf(1)) {
                 try {
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    const value = await this.contextsDeferred.get(id).promise;
-                    const channel = await value.getChannel();
+                    const channel = await context.getChannel();
                     return { mimeType: "fluid/object", status: 200, value: channel };
                 }
                 catch (error) {
-                    this.logger.sendErrorEvent({ eventName: "GetChannelFailedInRequest" }, error);
+                    this.mc.logger.sendErrorEvent({ eventName: "GetChannelFailedInRequest" }, error);
                     return (0, runtime_utils_1.createResponseError)(500, `Failed to get Channel: ${error}`, request);
                 }
             }
@@ -188,37 +227,56 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
     }
     async getChannel(id) {
         this.verifyNotClosed();
-        // TODO we don't assume any channels (even root) in the runtime. If you request a channel that doesn't exist
-        // we will never resolve the promise. May want a flag to getChannel that doesn't wait for the promise if
-        // it doesn't exist
-        if (!this.contextsDeferred.has(id)) {
-            this.contextsDeferred.set(id, new common_utils_1.Deferred());
-        }
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const context = await this.contextsDeferred.get(id).promise;
-        const channel = await context.getChannel();
-        return channel;
+        const context = this.contexts.get(id);
+        if (context === undefined) {
+            throw new telemetry_utils_1.LoggingError("Channel does not exist");
+        }
+        return context.getChannel();
     }
-    createChannel(id = (0, uuid_1.v4)(), type) {
+    /**
+     * Api which allows caller to create the channel first and then add it to the runtime.
+     * The channel type should be present in the registry, otherwise the runtime would reject
+     * the channel. Also the runtime used to create the channel object should be same to which
+     * it is added.
+     * @param channel - channel which needs to be added to the runtime.
+     */
+    addChannel(channel) {
+        const id = channel.id;
         if (id.includes("/")) {
-            throw new container_utils_1.UsageError(`Id cannot contain slashes: ${id}`);
+            throw new telemetry_utils_1.UsageError(`Id cannot contain slashes: ${id}`);
         }
         this.verifyNotClosed();
-        (0, common_utils_1.assert)(!this.contexts.has(id), 0x179 /* "createChannel() with existing ID" */);
-        this.notBoundedChannelContextSet.add(id);
-        const context = new localChannelContext_1.LocalChannelContext(id, this.sharedObjectRegistry, type, this, this.dataStoreContext, this.dataStoreContext.storage, this.logger, (content, localOpMetadata) => this.submitChannelOp(id, content, localOpMetadata), (address) => this.setChannelDirty(address), (srcHandle, outboundHandle) => this.addedGCOutboundReference(srcHandle, outboundHandle));
-        this.contexts.set(id, context);
-        if (this.contextsDeferred.has(id)) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            this.contextsDeferred.get(id).resolve(context);
+        (0, core_utils_1.assert)(!this.contexts.has(id), 0x865 /* addChannel() with existing ID */);
+        const type = channel.attributes.type;
+        const factory = this.sharedObjectRegistry.get(channel.attributes.type);
+        if (factory === undefined) {
+            throw new Error(`Channel Factory ${type} not registered`);
         }
-        else {
-            const deferred = new common_utils_1.Deferred();
-            deferred.resolve(context);
-            this.contextsDeferred.set(id, deferred);
+        this.createChannelContext(channel);
+        // Channels (DDS) should not be created in summarizer client.
+        this.identifyLocalChangeInSummarizer("DDSCreatedInSummarizer", id, type);
+    }
+    createChannel(id = (0, uuid_1.v4)(), type) {
+        if (id.includes("/")) {
+            throw new telemetry_utils_1.UsageError(`Id cannot contain slashes: ${id}`);
         }
-        (0, common_utils_1.assert)(!!context.channel, 0x17a /* "Channel should be loaded when created!!" */);
-        return context.channel;
+        this.verifyNotClosed();
+        (0, core_utils_1.assert)(!this.contexts.has(id), 0x179 /* "createChannel() with existing ID" */);
+        (0, core_utils_1.assert)(type !== undefined, 0x209 /* "Factory Type should be defined" */);
+        const factory = this.sharedObjectRegistry.get(type);
+        if (factory === undefined) {
+            throw new Error(`Channel Factory ${type} not registered`);
+        }
+        const channel = factory.create(this, id);
+        this.createChannelContext(channel);
+        // Channels (DDS) should not be created in summarizer client.
+        this.identifyLocalChangeInSummarizer("DDSCreatedInSummarizer", id, type);
+        return channel;
+    }
+    createChannelContext(channel) {
+        this.notBoundedChannelContextSet.add(channel.id);
+        const context = new localChannelContext_1.LocalChannelContext(channel, this, this.dataStoreContext, this.dataStoreContext.storage, this.logger, (content, localOpMetadata) => this.submitChannelOp(channel.id, content, localOpMetadata), (address) => this.setChannelDirty(address), (srcHandle, outboundHandle) => this.addedGCOutboundReference(srcHandle, outboundHandle));
+        this.contexts.set(channel.id, context);
     }
     /**
      * Binds a channel with the runtime. If the runtime is attached we will attach the channel right away.
@@ -226,7 +284,7 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
      * @param channel - channel to be registered.
      */
     bindChannel(channel) {
-        (0, common_utils_1.assert)(this.notBoundedChannelContextSet.has(channel.id), 0x17b /* "Channel to be binded should be in not bounded set" */);
+        (0, core_utils_1.assert)(this.notBoundedChannelContextSet.has(channel.id), 0x17b /* "Channel to be bound should be in not bounded set" */);
         this.notBoundedChannelContextSet.delete(channel.id);
         // If our data store is attached, then attach the channel.
         if (this.isAttached) {
@@ -248,11 +306,14 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
     }
     /**
      * This function is called when a data store becomes root. It does the following:
+     *
      * 1. Marks the data store locally visible in the container.
+     *
      * 2. Attaches the graph of all the handles bound to it.
+     *
      * 3. Calls into the data store context to mark it visible in the container too. If the container is globally
-     *    visible, it will mark us globally visible. Otherwise, it will mark us globally visible when it becomes
-     *    globally visible.
+     * visible, it will mark us globally visible. Otherwise, it will mark us globally visible when it becomes
+     * globally visible.
      */
     makeVisibleAndAttachGraph() {
         if (this.visibilityState !== runtime_definitions_1.VisibilityState.NotVisible) {
@@ -263,7 +324,7 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
             handle.attachGraph();
         });
         this.pendingHandlesToMakeVisible.clear();
-        this.bindToContext();
+        this.dataStoreContext.makeLocallyVisible();
     }
     /**
      * This function is called when a handle to this data store is added to a visible DDS.
@@ -271,20 +332,6 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
     attachGraph() {
         this.makeVisibleAndAttachGraph();
     }
-    /**
-     * Binds this runtime to the container
-     * This includes the following:
-     * 1. Sending an Attach op that includes all existing state
-     * 2. Attaching the graph if the data store becomes attached.
-     */
-    bindToContext() {
-        if (this.bindState !== container_definitions_1.BindState.NotBound) {
-            return;
-        }
-        this.bindState = container_definitions_1.BindState.Binding;
-        this.dataStoreContext.bindToContext();
-        this.bindState = container_definitions_1.BindState.Bound;
-    }
     bind(handle) {
         // If visible, attach the incoming handle's graph. Else, this will be done when we become visible.
         if (this.visibilityState !== runtime_definitions_1.VisibilityState.NotVisible) {
@@ -306,9 +353,14 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
     getAudience() {
         return this.audience;
     }
-    async uploadBlob(blob) {
+    async uploadBlob(blob, signal) {
         this.verifyNotClosed();
-        return this.dataStoreContext.uploadBlob(blob);
+        return this.dataStoreContext.uploadBlob(blob, signal);
+    }
+    createRemoteChannelContext(attachMessage, summarizerNodeParams) {
+        const flatBlobs = new Map();
+        const snapshotTree = (0, driver_utils_1.buildSnapshotTree)(attachMessage.snapshot.entries, flatBlobs);
+        return new remoteChannelContext_1.RemoteChannelContext(this, this.dataStoreContext, this.dataStoreContext.storage, (content, localContentMetadata) => this.submitChannelOp(attachMessage.id, content, localContentMetadata), (address) => this.setChannelDirty(address), (srcHandle, outboundHandle) => this.addedGCOutboundReference(srcHandle, outboundHandle), attachMessage.id, snapshotTree, this.sharedObjectRegistry, flatBlobs, this.dataStoreContext.getCreateChildSummarizerNodeFn(attachMessage.id, summarizerNodeParams), attachMessage.type);
     }
     process(message, local, localOpMetadata) {
         this.verifyNotClosed();
@@ -321,28 +373,17 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
                     // If a non-local operation then go and create the object
                     // Otherwise mark it as officially attached.
                     if (local) {
-                        (0, common_utils_1.assert)(this.pendingAttach.has(id), 0x17c /* "Unexpected attach (local) channel OP" */);
-                        this.pendingAttach.delete(id);
+                        (0, core_utils_1.assert)(this.pendingAttach.delete(id), 0x17c /* "Unexpected attach (local) channel OP" */);
                     }
                     else {
-                        (0, common_utils_1.assert)(!this.contexts.has(id), 0x17d);
-                        const flatBlobs = new Map();
-                        const snapshotTree = (0, driver_utils_1.buildSnapshotTree)(attachMessage.snapshot.entries, flatBlobs);
-                        const remoteChannelContext = new remoteChannelContext_1.RemoteChannelContext(this, this.dataStoreContext, this.dataStoreContext.storage, (content, localContentMetadata) => this.submitChannelOp(id, content, localContentMetadata), (address) => this.setChannelDirty(address), (srcHandle, outboundHandle) => this.addedGCOutboundReference(srcHandle, outboundHandle), id, snapshotTree, this.sharedObjectRegistry, flatBlobs, this.dataStoreContext.getCreateChildSummarizerNodeFn(id, {
+                        (0, core_utils_1.assert)(!this.contexts.has(id), 0x17d /* "Unexpected attach channel OP" */);
+                        const summarizerNodeParams = {
                             type: runtime_definitions_1.CreateSummarizerNodeSource.FromAttach,
                             sequenceNumber: message.sequenceNumber,
                             snapshot: attachMessage.snapshot,
-                        }), async () => this.getChannelBaseGCDetails(id), attachMessage.type);
+                        };
+                        const remoteChannelContext = this.createRemoteChannelContext(attachMessage, summarizerNodeParams);
                         this.contexts.set(id, remoteChannelContext);
-                        if (this.contextsDeferred.has(id)) {
-                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                            this.contextsDeferred.get(id).resolve(remoteChannelContext);
-                        }
-                        else {
-                            const deferred = new common_utils_1.Deferred();
-                            deferred.resolve(remoteChannelContext);
-                            this.contextsDeferred.set(id, deferred);
-                        }
                     }
                     break;
                 }
@@ -354,7 +395,7 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
             this.emit("op", message);
         }
         catch (error) {
-            throw container_utils_1.DataProcessingError.wrapIfUnrecognized(error, "fluidDataStoreRuntimeFailedToProcessMessage", message);
+            throw telemetry_utils_1.DataProcessingError.wrapIfUnrecognized(error, "fluidDataStoreRuntimeFailedToProcessMessage", message);
         }
     }
     processSignal(message, local) {
@@ -364,13 +405,13 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
         return (
         // Added in createChannel
         // Removed when bindChannel is called
-        !this.notBoundedChannelContextSet.has(id)
+        !this.notBoundedChannelContextSet.has(id) &&
             // Added in bindChannel only if this is not attached yet
             // Removed when this is attached by calling attachGraph
-            && !this.localChannelContextQueue.has(id)
+            !this.localChannelContextQueue.has(id) &&
             // Added in attachChannel called by bindChannel
             // Removed when attach op is broadcast
-            && !this.pendingAttach.has(id));
+            !this.pendingAttach.has(id));
     }
     /**
      * Returns the outbound routes of this channel. Currently, all contexts in this channel are considered
@@ -401,22 +442,27 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
      * Generates data used for garbage collection. This includes a list of GC nodes that represent this channel
      * including any of its child channel contexts. Each node has a set of outbound routes to other GC nodes in the
      * document. It does the following:
+     *
      * 1. Calls into each child context to get its GC data.
+     *
      * 2. Prefixes the child context's id to the GC nodes in the child's GC data. This makes sure that the node can be
-     *    identified as belonging to the child.
+     * identified as belonging to the child.
+     *
      * 3. Adds a GC node for this channel to the nodes received from the children. All these nodes together represent
-     *    the GC data of this channel.
+     * the GC data of this channel.
+     *
      * @param fullGC - true to bypass optimizations and force full generation of GC data.
      */
     async getGCData(fullGC = false) {
-        const builder = new garbage_collector_1.GCDataBuilder();
+        const builder = new runtime_utils_1.GCDataBuilder();
         // Iterate over each channel context and get their GC data.
         await Promise.all(Array.from(this.contexts)
             .filter(([contextId, _]) => {
             // Get GC data only for attached contexts. Detached contexts are not connected in the GC reference
             // graph so any references they might have won't be connected as well.
             return this.isChannelAttached(contextId);
-        }).map(async ([contextId, context]) => {
+        })
+            .map(async ([contextId, context]) => {
             const contextGCData = await context.getGCData(fullGC);
             // Prefix the child's id to the ids of its GC nodes so they can be identified as belonging to the child.
             // This also gradually builds the id of each node to be a path from the root.
@@ -429,20 +475,17 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
      * After GC has run, called to notify this channel of routes that are used in it. It calls the child contexts to
      * update their used routes.
      * @param usedRoutes - The routes that are used in all contexts in this channel.
-     * @param gcTimestamp - The time when GC was run that generated these used routes. If any node becomes unreferenced
-     * as part of this GC run, this should be used to update the time when it happens.
      */
-    updateUsedRoutes(usedRoutes, gcTimestamp) {
-        var _a;
+    updateUsedRoutes(usedRoutes) {
         // Get a map of channel ids to routes used in it.
-        const usedContextRoutes = (0, garbage_collector_1.unpackChildNodesUsedRoutes)(usedRoutes);
+        const usedContextRoutes = (0, runtime_utils_1.unpackChildNodesUsedRoutes)(usedRoutes);
         // Verify that the used routes are correct.
         for (const [id] of usedContextRoutes) {
-            (0, common_utils_1.assert)(this.contexts.has(id), 0x17e /* "Used route does not belong to any known context" */);
+            (0, core_utils_1.assert)(this.contexts.has(id), 0x17e /* "Used route does not belong to any known context" */);
         }
         // Update the used routes in each context. Used routes is empty for unused context.
         for (const [contextId, context] of this.contexts) {
-            context.updateUsedRoutes((_a = usedContextRoutes.get(contextId)) !== null && _a !== void 0 ? _a : [], gcTimestamp);
+            context.updateUsedRoutes(usedContextRoutes.get(contextId) ?? []);
         }
     }
     /**
@@ -452,31 +495,7 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
      * @param outboundHandle - The handle of the outbound node that is referenced.
      */
     addedGCOutboundReference(srcHandle, outboundHandle) {
-        var _a, _b;
-        (_b = (_a = this.dataStoreContext).addedGCOutboundReference) === null || _b === void 0 ? void 0 : _b.call(_a, srcHandle, outboundHandle);
-    }
-    /**
-     * Returns the base GC details for the channel with the given id. This is used to initialize its GC state.
-     * @param channelId - The id of the channel context that is asked for the initial GC details.
-     * @returns the requested channel's base GC details.
-     */
-    async getChannelBaseGCDetails(channelId) {
-        var _a;
-        let channelBaseGCDetails = (await this.channelsBaseGCDetails).get(channelId);
-        if (channelBaseGCDetails === undefined) {
-            channelBaseGCDetails = {};
-        }
-        else if (((_a = channelBaseGCDetails.gcData) === null || _a === void 0 ? void 0 : _a.gcNodes) !== undefined) {
-            // Note: if the child channel has an explicit handle route to its parent, it will be removed here and
-            // expected to be added back by the parent when getGCData is called.
-            (0, garbage_collector_1.removeRouteFromAllNodes)(channelBaseGCDetails.gcData.gcNodes, this.absolutePath);
-        }
-        // Currently, channel context's are always considered used. So, it there are no used routes for it, we still
-        // need to mark it as used. Add self-route (empty string) to the channel context's used routes.
-        if (channelBaseGCDetails.usedRoutes === undefined || channelBaseGCDetails.usedRoutes.length === 0) {
-            channelBaseGCDetails.usedRoutes = [""];
-        }
-        return channelBaseGCDetails;
+        this.dataStoreContext.addedGCOutboundReference?.(srcHandle, outboundHandle);
     }
     /**
      * Returns a summary at the current sequence number.
@@ -491,11 +510,12 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
             .filter(([contextId, _]) => {
             const isAttached = this.isChannelAttached(contextId);
             // We are not expecting local dds! Summary may not capture local state.
-            (0, common_utils_1.assert)(isAttached, 0x17f /* "Not expecting detached channels during summarize" */);
+            (0, core_utils_1.assert)(isAttached, 0x17f /* "Not expecting detached channels during summarize" */);
             // If the object is registered - and we have received the sequenced op creating the object
             // (i.e. it has a base mapping) - then we go ahead and summarize
             return isAttached;
-        }).map(async ([contextId, context]) => {
+        })
+            .map(async ([contextId, context]) => {
             const contextSummary = await context.summarize(fullTree, trackState, telemetryContext);
             summaryBuilder.addWithStats(contextId, contextSummary);
         }));
@@ -506,20 +526,20 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
          * back-compat 0.59.1000 - getAttachSummary() is called when making a data store globally visible (previously
          * attaching state). Ideally, attachGraph() should have already be called making it locally visible. However,
          * before visibility state was added, this may not have been the case and getAttachSummary() could be called:
-         * 1) Before attaching the data store - When a detached container is attached.
-         * 2) After attaching the data store - When a data store is created and bound in an attached container.
+         *
+         * 1. Before attaching the data store - When a detached container is attached.
+         *
+         * 2. After attaching the data store - When a data store is created and bound in an attached container.
          *
          * The basic idea is that all local object should become locally visible before they are globally visible.
          */
         this.attachGraph();
-        /**
-         * This assert cannot be added now due to back-compat. To be uncommented when the following issue is fixed -
-         * https://github.com/microsoft/FluidFramework/issues/9688.
-         *
-         * assert(this.visibilityState === VisibilityState.LocallyVisible,
-         *   "The data store should be locally visible when generating attach summary",
-         * );
-         */
+        // This assert cannot be added now due to back-compat. To be uncommented when the following issue is fixed -
+        // https://github.com/microsoft/FluidFramework/issues/9688.
+        //
+        // assert(this.visibilityState === VisibilityState.LocallyVisible,
+        //  "The data store should be locally visible when generating attach summary",
+        // );
         const summaryBuilder = new runtime_utils_1.SummaryTreeBuilder();
         // Craft the .attributes file for each shared object
         for (const [contextId, context] of this.contexts) {
@@ -530,13 +550,13 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
                 let summaryTree;
                 if (context.isLoaded) {
                     const contextSummary = context.getAttachSummary(telemetryContext);
-                    (0, common_utils_1.assert)(contextSummary.summary.type === protocol_definitions_1.SummaryType.Tree, 0x180 /* "getAttachSummary should always return a tree" */);
+                    (0, core_utils_1.assert)(contextSummary.summary.type === protocol_definitions_1.SummaryType.Tree, 0x180 /* "getAttachSummary should always return a tree" */);
                     summaryTree = { stats: contextSummary.stats, summary: contextSummary.summary };
                 }
                 else {
                     // If this channel is not yet loaded, then there should be no changes in the snapshot from which
                     // it was created as it is detached container. So just use the previous snapshot.
-                    (0, common_utils_1.assert)(!!this.dataStoreContext.baseSnapshot, 0x181 /* "BaseSnapshot should be there as detached container loaded from snapshot" */);
+                    (0, core_utils_1.assert)(!!this.dataStoreContext.baseSnapshot, 0x181 /* "BaseSnapshot should be there as detached container loaded from snapshot" */);
                     summaryTree = (0, runtime_utils_1.convertSnapshotTreeToSummaryTree)(this.dataStoreContext.baseSnapshot.trees[contextId]);
                 }
                 summaryBuilder.addWithStats(contextId, summaryTree);
@@ -547,9 +567,15 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
     submitMessage(type, content, localOpMetadata) {
         this.submit(type, content, localOpMetadata);
     }
-    submitSignal(type, content) {
+    /**
+     * Submits the signal to be sent to other clients.
+     * @param type - Type of the signal.
+     * @param content - Content of the signal.
+     * @param targetClientId - When specified, the signal is only sent to the provided client id.
+     */
+    submitSignal(type, content, targetClientId) {
         this.verifyNotClosed();
-        return this.dataStoreContext.submitSignal(type, content);
+        return this.dataStoreContext.submitSignal(type, content, targetClientId);
     }
     /**
      * Will return when the data store is attached.
@@ -567,8 +593,8 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
             return;
         }
         channel.handle.attachGraph();
-        (0, common_utils_1.assert)(this.isAttached, 0x182 /* "Data store should be attached to attach the channel." */);
-        (0, common_utils_1.assert)(this.visibilityState === runtime_definitions_1.VisibilityState.GloballyVisible, 0x2d0 /* "Data store should be globally visible to attach channels." */);
+        (0, core_utils_1.assert)(this.isAttached, 0x182 /* "Data store should be attached to attach the channel." */);
+        (0, core_utils_1.assert)(this.visibilityState === runtime_definitions_1.VisibilityState.GloballyVisible, 0x2d0 /* "Data store should be globally visible to attach channels." */);
         const summarizeResult = (0, channelContext_1.summarizeChannel)(channel, true /* fullTree */, false /* trackState */);
         // Attach message needs the summary in ITree format. Convert the ISummaryTree into an ITree.
         const snapshot = (0, runtime_utils_1.convertSummaryTreeToITree)(summarizeResult.summary);
@@ -577,7 +603,7 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
             snapshot,
             type: channel.attributes.type,
         };
-        this.pendingAttach.set(channel.id, message);
+        this.pendingAttach.add(channel.id);
         this.submit(DataStoreMessageType.Attach, message);
         const context = this.contexts.get(channel.id);
         context.makeVisible();
@@ -600,21 +626,20 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
     reSubmit(type, content, localOpMetadata) {
         this.verifyNotClosed();
         switch (type) {
-            case DataStoreMessageType.ChannelOp:
-                {
-                    // For Operations, find the right channel and trigger resubmission on it.
-                    const envelope = content;
-                    const channelContext = this.contexts.get(envelope.address);
-                    (0, common_utils_1.assert)(!!channelContext, 0x183 /* "There should be a channel context for the op" */);
-                    channelContext.reSubmit(envelope.contents, localOpMetadata);
-                    break;
-                }
+            case DataStoreMessageType.ChannelOp: {
+                // For Operations, find the right channel and trigger resubmission on it.
+                const envelope = content;
+                const channelContext = this.contexts.get(envelope.address);
+                (0, core_utils_1.assert)(!!channelContext, 0x183 /* "There should be a channel context for the op" */);
+                channelContext.reSubmit(envelope.contents, localOpMetadata);
+                break;
+            }
             case DataStoreMessageType.Attach:
                 // For Attach messages, just submit them again.
                 this.submit(type, content, localOpMetadata);
                 break;
             default:
-                (0, common_utils_1.unreachableCase)(type);
+                (0, core_utils_1.unreachableCase)(type);
         }
     }
     /**
@@ -625,25 +650,42 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
     rollback(type, content, localOpMetadata) {
         this.verifyNotClosed();
         switch (type) {
-            case DataStoreMessageType.ChannelOp:
-                {
-                    // For Operations, find the right channel and trigger resubmission on it.
-                    const envelope = content;
-                    const channelContext = this.contexts.get(envelope.address);
-                    (0, common_utils_1.assert)(!!channelContext, 0x2ed /* "There should be a channel context for the op" */);
-                    channelContext.rollback(envelope.contents, localOpMetadata);
-                    break;
-                }
+            case DataStoreMessageType.ChannelOp: {
+                // For Operations, find the right channel and trigger resubmission on it.
+                const envelope = content;
+                const channelContext = this.contexts.get(envelope.address);
+                (0, core_utils_1.assert)(!!channelContext, 0x2ed /* "There should be a channel context for the op" */);
+                channelContext.rollback(envelope.contents, localOpMetadata);
+                break;
+            }
             default:
                 throw new telemetry_utils_1.LoggingError(`Can't rollback ${type} message`);
         }
     }
     async applyStashedOp(content) {
-        const envelope = content;
-        const channelContext = this.contexts.get(envelope.address);
-        (0, common_utils_1.assert)(!!channelContext, 0x184 /* "There should be a channel context for the op" */);
-        await channelContext.getChannel();
-        return channelContext.applyStashedOp(envelope.contents);
+        const type = content?.type;
+        switch (type) {
+            case DataStoreMessageType.Attach: {
+                const attachMessage = content.content;
+                // local means this node will throw if summarized; this is fine because only interactive clients will have stashed ops
+                const summarizerNodeParams = {
+                    type: runtime_definitions_1.CreateSummarizerNodeSource.Local,
+                };
+                const context = this.createRemoteChannelContext(attachMessage, summarizerNodeParams);
+                this.pendingAttach.add(attachMessage.id);
+                this.contexts.set(attachMessage.id, context);
+                return;
+            }
+            case DataStoreMessageType.ChannelOp: {
+                const envelope = content.content;
+                const channelContext = this.contexts.get(envelope.address);
+                (0, core_utils_1.assert)(!!channelContext, 0x184 /* "There should be a channel context for the op" */);
+                await channelContext.getChannel();
+                return channelContext.applyStashedOp(envelope.contents);
+            }
+            default:
+                (0, core_utils_1.unreachableCase)(type);
+        }
     }
     setChannelDirty(address) {
         this.verifyNotClosed();
@@ -652,9 +694,12 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
     processChannelOp(message, local, localOpMetadata) {
         this.verifyNotClosed();
         const envelope = message.contents;
-        const transformed = Object.assign(Object.assign({}, message), { contents: envelope.contents });
+        const transformed = {
+            ...message,
+            contents: envelope.contents,
+        };
         const channelContext = this.contexts.get(envelope.address);
-        (0, common_utils_1.assert)(!!channelContext, 0x185 /* "Channel not found" */);
+        (0, core_utils_1.assert)(!!channelContext, 0x185 /* "Channel not found" */);
         channelContext.processOp(transformed, local, localOpMetadata);
         return channelContext;
     }
@@ -672,7 +717,7 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
              */
             this.attachGraph();
             this._attachState = container_definitions_1.AttachState.Attaching;
-            (0, common_utils_1.assert)(this.visibilityState === runtime_definitions_1.VisibilityState.LocallyVisible, 0x2d1 /* "Data store should be locally visible before it can become globally visible." */);
+            (0, core_utils_1.assert)(this.visibilityState === runtime_definitions_1.VisibilityState.LocallyVisible, 0x2d1 /* "Data store should be locally visible before it can become globally visible." */);
             // Mark the data store globally visible and make its child channels visible as well.
             this.visibilityState = runtime_definitions_1.VisibilityState.GloballyVisible;
             this.localChannelContextQueue.forEach((channel) => {
@@ -684,7 +729,7 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
             this.emit("attaching");
         });
         this.dataStoreContext.once("attached", () => {
-            (0, common_utils_1.assert)(this.visibilityState === runtime_definitions_1.VisibilityState.GloballyVisible, 0x2d2 /* "Data store should be globally visible when its attached." */);
+            (0, core_utils_1.assert)(this.visibilityState === runtime_definitions_1.VisibilityState.GloballyVisible, 0x2d2 /* "Data store should be globally visible when its attached." */);
             this._attachState = container_definitions_1.AttachState.Attached;
             this.emit("attached");
         });
@@ -694,6 +739,30 @@ class FluidDataStoreRuntime extends common_utils_1.TypedEventEmitter {
             throw new telemetry_utils_1.LoggingError("Runtime is closed");
         }
     }
+    /**
+     * Summarizer client should not have local changes. These changes can become part of the summary and can break
+     * eventual consistency. For example, the next summary (say at ref seq# 100) may contain these changes whereas
+     * other clients that are up-to-date till seq# 100 may not have them yet.
+     */
+    identifyLocalChangeInSummarizer(eventName, channelId, channelType) {
+        if (this.clientDetails.type !== "summarizer" || this.localChangesTelemetryCount <= 0) {
+            return;
+        }
+        // Log a telemetry if there are local changes in the summarizer. This will give us data on how often
+        // this is happening and which data stores do this. The eventual goal is to disallow local changes
+        // in the summarizer and the data will help us plan this.
+        this.mc.logger.sendTelemetryEvent({
+            eventName,
+            ...(0, telemetry_utils_1.tagCodeArtifacts)({
+                channelType,
+                channelId,
+                fluidDataStoreId: this.id,
+                fluidDataStorePackagePath: this.dataStoreContext.packagePath.join("/"),
+            }),
+            stack: (0, telemetry_utils_1.generateStack)(),
+        });
+        this.localChangesTelemetryCount--;
+    }
 }
 exports.FluidDataStoreRuntime = FluidDataStoreRuntime;
 /**
@@ -701,6 +770,7 @@ exports.FluidDataStoreRuntime = FluidDataStoreRuntime;
  * Request handler is only called when data store can't resolve request, i.e. for custom requests.
  * @param Base - base class, inherits from FluidDataStoreRuntime
  * @param requestHandler - request handler to mix in
+ * @internal
  */
 const mixinRequestHandler = (requestHandler, Base = FluidDataStoreRuntime) => class RuntimeWithRequestHandler extends Base {
     async request(request) {
@@ -717,6 +787,7 @@ exports.mixinRequestHandler = mixinRequestHandler;
  * @param handler - handler that returns info about blob to be added to summary.
  * Or undefined not to add anything to summary.
  * @param Base - base class, inherits from FluidDataStoreRuntime
+ * @alpha
  */
 const mixinSummaryHandler = (handler, Base = FluidDataStoreRuntime) => class RuntimeWithSummarizerHandler extends Base {
     addBlob(summary, path, content) {
@@ -741,12 +812,18 @@ const mixinSummaryHandler = (handler, Base = FluidDataStoreRuntime) => class Run
     }
     async summarize(...args) {
         const summary = await super.summarize(...args);
-        const content = await handler(this);
-        if (content !== undefined) {
-            this.addBlob(summary, content.path, content.content);
+        try {
+            const content = await handler(this);
+            if (content !== undefined) {
+                this.addBlob(summary, content.path, content.content);
+            }
+        }
+        catch (e) {
+            // Any error coming from app-provided handler should be marked as DataProcessingError
+            throw telemetry_utils_1.DataProcessingError.wrapIfUnrecognized(e, "mixinSummaryHandler");
         }
         return summary;
     }
 };
 exports.mixinSummaryHandler = mixinSummaryHandler;
-//# sourceMappingURL=dataStoreRuntime.js.map
+//# sourceMappingURL=dataStoreRuntime.cjs.map