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

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

@@ -2,19 +2,22 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { BindState, AttachState, } from "@fluidframework/container-definitions";
-import { DataProcessingError, UsageError } from "@fluidframework/container-utils";
-import { assert, Deferred, LazyPromise, TypedEventEmitter, unreachableCase, } from "@fluidframework/common-utils";
-import { ChildLogger, LoggingError, raiseConnectedEvent, } from "@fluidframework/telemetry-utils";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { DataProcessingError, generateStack, LoggingError, raiseConnectedEvent, createChildMonitoringContext, tagCodeArtifacts, UsageError, } from "@fluidframework/telemetry-utils";
+import { assert, Deferred, LazyPromise, unreachableCase } from "@fluidframework/core-utils";
+import { AttachState, } from "@fluidframework/container-definitions";
 import { buildSnapshotTree } from "@fluidframework/driver-utils";
 import { SummaryType, } from "@fluidframework/protocol-definitions";
 import { CreateSummarizerNodeSource, VisibilityState, } from "@fluidframework/runtime-definitions";
-import { convertSnapshotTreeToSummaryTree, convertSummaryTreeToITree, generateHandleContextPath, RequestParser, SummaryTreeBuilder, create404Response, createResponseError, exceptionToResponse, } from "@fluidframework/runtime-utils";
-import { GCDataBuilder, removeRouteFromAllNodes, unpackChildNodesGCDetails, unpackChildNodesUsedRoutes, } from "@fluidframework/garbage-collector";
+import { convertSnapshotTreeToSummaryTree, convertSummaryTreeToITree, generateHandleContextPath, RequestParser, SummaryTreeBuilder, create404Response, createResponseError, exceptionToResponse, GCDataBuilder, unpackChildNodesUsedRoutes, } from "@fluidframework/runtime-utils";
 import { v4 as uuid } from "uuid";
-import { summarizeChannel } from "./channelContext";
-import { LocalChannelContext, LocalChannelContextBase, RehydratedLocalChannelContext } from "./localChannelContext";
-import { RemoteChannelContext } from "./remoteChannelContext";
+import { summarizeChannel } from "./channelContext.mjs";
+import { LocalChannelContext, LocalChannelContextBase, RehydratedLocalChannelContext, } from "./localChannelContext.mjs";
+import { RemoteChannelContext } from "./remoteChannelContext.mjs";
+import { FluidObjectHandle } from "./fluidHandle.mjs";
+/**
+ * @alpha
+ */
 export var DataStoreMessageType;
 (function (DataStoreMessageType) {
     // Creates a new channel
@@ -23,16 +26,83 @@ export var DataStoreMessageType;
 })(DataStoreMessageType || (DataStoreMessageType = {}));
 /**
  * Base data store class
+ * @alpha
  */
 export class FluidDataStoreRuntime extends TypedEventEmitter {
-    constructor(dataStoreContext, sharedObjectRegistry, existing) {
+    get connected() {
+        return this.dataStoreContext.connected;
+    }
+    get clientId() {
+        return this.dataStoreContext.clientId;
+    }
+    get clientDetails() {
+        return this.dataStoreContext.clientDetails;
+    }
+    get isAttached() {
+        return this.attachState !== AttachState.Detached;
+    }
+    get attachState() {
+        return this._attachState;
+    }
+    get absolutePath() {
+        return 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.pendingAttach = new Set();
         this.deferredAttached = new Deferred();
         this.localChannelContextQueue = new Map();
         this.notBoundedChannelContextSet = new Set();
@@ -40,20 +110,21 @@ export class FluidDataStoreRuntime extends TypedEventEmitter {
         // store becomes visible.
         this.pendingHandlesToMakeVisible = new Set();
         assert(!dataStoreContext.id.includes("/"), 0x30e /* Id cannot contain slashes. DataStoreContext should have validated this. */);
-        this.logger = ChildLogger.create(dataStoreContext.logger, "FluidDataStoreRuntime", { all: { dataStoreId: uuid() } });
+        this.mc = createChildMonitoringContext({
+            logger: dataStoreContext.logger,
+            namespace: "FluidDataStoreRuntime",
+            properties: {
+                all: { dataStoreId: uuid() },
+            },
+        });
         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 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 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") {
@@ -77,29 +148,31 @@ export class FluidDataStoreRuntime extends TypedEventEmitter {
                     }
                 }
                 else {
-                    channelContext = new 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: CreateSummarizerNodeSource.FromSummary }), async () => this.getChannelBaseGCDetails(path));
+                    channelContext = new 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: CreateSummarizerNodeSource.FromSummary,
+                    }));
                 }
-                const deferred = new Deferred();
-                deferred.resolve(channelContext);
                 this.contexts.set(path, channelContext);
-                this.contextsDeferred.set(path, deferred);
             });
         }
+        this.entryPoint = new FluidObjectHandle(new 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 ? BindState.Bound : 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 === AttachState.Detached
-                ? VisibilityState.LocallyVisible : VisibilityState.GloballyVisible;
+            this.visibilityState =
+                dataStoreContext.attachState === AttachState.Detached
+                    ? VisibilityState.LocallyVisible
+                    : VisibilityState.GloballyVisible;
         }
         else {
             this.visibilityState = VisibilityState.NotVisible;
@@ -108,43 +181,10 @@ export class FluidDataStoreRuntime extends 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 !== AttachState.Detached;
-    }
-    get attachState() {
-        return this._attachState;
-    }
-    get absolutePath() {
-        return 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;
@@ -161,18 +201,17 @@ export class FluidDataStoreRuntime extends TypedEventEmitter {
             const parser = 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 createResponseError(500, `Failed to get Channel: ${error}`, request);
                 }
             }
@@ -185,37 +224,56 @@ export class FluidDataStoreRuntime extends 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 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 LoggingError("Channel does not exist");
+        }
+        return context.getChannel();
     }
-    createChannel(id = uuid(), 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 UsageError(`Id cannot contain slashes: ${id}`);
         }
         this.verifyNotClosed();
-        assert(!this.contexts.has(id), 0x179 /* "createChannel() with existing ID" */);
-        this.notBoundedChannelContextSet.add(id);
-        const context = new 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);
+        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 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 = uuid(), type) {
+        if (id.includes("/")) {
+            throw new UsageError(`Id cannot contain slashes: ${id}`);
         }
-        assert(!!context.channel, 0x17a /* "Channel should be loaded when created!!" */);
-        return context.channel;
+        this.verifyNotClosed();
+        assert(!this.contexts.has(id), 0x179 /* "createChannel() with existing ID" */);
+        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(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.
@@ -223,7 +281,7 @@ export class FluidDataStoreRuntime extends TypedEventEmitter {
      * @param channel - channel to be registered.
      */
     bindChannel(channel) {
-        assert(this.notBoundedChannelContextSet.has(channel.id), 0x17b /* "Channel to be binded should be in not bounded set" */);
+        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) {
@@ -245,11 +303,14 @@ export class FluidDataStoreRuntime extends 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 !== VisibilityState.NotVisible) {
@@ -260,7 +321,7 @@ export class FluidDataStoreRuntime extends 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.
@@ -268,20 +329,6 @@ export class FluidDataStoreRuntime extends 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 !== BindState.NotBound) {
-            return;
-        }
-        this.bindState = BindState.Binding;
-        this.dataStoreContext.bindToContext();
-        this.bindState = BindState.Bound;
-    }
     bind(handle) {
         // If visible, attach the incoming handle's graph. Else, this will be done when we become visible.
         if (this.visibilityState !== VisibilityState.NotVisible) {
@@ -303,9 +350,14 @@ export class FluidDataStoreRuntime extends 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 = buildSnapshotTree(attachMessage.snapshot.entries, flatBlobs);
+        return new 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();
@@ -318,28 +370,17 @@ export class FluidDataStoreRuntime extends TypedEventEmitter {
                     // If a non-local operation then go and create the object
                     // Otherwise mark it as officially attached.
                     if (local) {
-                        assert(this.pendingAttach.has(id), 0x17c /* "Unexpected attach (local) channel OP" */);
-                        this.pendingAttach.delete(id);
+                        assert(this.pendingAttach.delete(id), 0x17c /* "Unexpected attach (local) channel OP" */);
                     }
                     else {
-                        assert(!this.contexts.has(id), 0x17d);
-                        const flatBlobs = new Map();
-                        const snapshotTree = buildSnapshotTree(attachMessage.snapshot.entries, flatBlobs);
-                        const remoteChannelContext = new 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, {
+                        assert(!this.contexts.has(id), 0x17d /* "Unexpected attach channel OP" */);
+                        const summarizerNodeParams = {
                             type: 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 Deferred();
-                            deferred.resolve(remoteChannelContext);
-                            this.contextsDeferred.set(id, deferred);
-                        }
                     }
                     break;
                 }
@@ -361,13 +402,13 @@ export class FluidDataStoreRuntime extends 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
@@ -398,11 +439,15 @@ export class FluidDataStoreRuntime extends 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) {
@@ -413,7 +458,8 @@ export class FluidDataStoreRuntime extends TypedEventEmitter {
             // 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.
@@ -426,11 +472,8 @@ export class FluidDataStoreRuntime extends 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 = unpackChildNodesUsedRoutes(usedRoutes);
         // Verify that the used routes are correct.
@@ -439,7 +482,7 @@ export class FluidDataStoreRuntime extends TypedEventEmitter {
         }
         // 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) ?? []);
         }
     }
     /**
@@ -449,31 +492,7 @@ export class FluidDataStoreRuntime extends 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.
-            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.
@@ -492,7 +511,8 @@ export class FluidDataStoreRuntime extends TypedEventEmitter {
             // 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);
         }));
@@ -503,20 +523,20 @@ export class FluidDataStoreRuntime extends 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 SummaryTreeBuilder();
         // Craft the .attributes file for each shared object
         for (const [contextId, context] of this.contexts) {
@@ -544,9 +564,15 @@ export class FluidDataStoreRuntime extends 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.
@@ -574,7 +600,7 @@ export class FluidDataStoreRuntime extends 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();
@@ -597,15 +623,14 @@ export class FluidDataStoreRuntime extends 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);
-                    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);
+                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);
@@ -622,25 +647,42 @@ export class FluidDataStoreRuntime extends 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);
-                    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);
+                assert(!!channelContext, 0x2ed /* "There should be a channel context for the op" */);
+                channelContext.rollback(envelope.contents, localOpMetadata);
+                break;
+            }
             default:
                 throw new LoggingError(`Can't rollback ${type} message`);
         }
     }
     async applyStashedOp(content) {
-        const envelope = content;
-        const channelContext = this.contexts.get(envelope.address);
-        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: 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);
+                assert(!!channelContext, 0x184 /* "There should be a channel context for the op" */);
+                await channelContext.getChannel();
+                return channelContext.applyStashedOp(envelope.contents);
+            }
+            default:
+                unreachableCase(type);
+        }
     }
     setChannelDirty(address) {
         this.verifyNotClosed();
@@ -649,7 +691,10 @@ export class FluidDataStoreRuntime extends 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);
         assert(!!channelContext, 0x185 /* "Channel not found" */);
         channelContext.processOp(transformed, local, localOpMetadata);
@@ -691,12 +736,37 @@ export class FluidDataStoreRuntime extends TypedEventEmitter {
             throw new 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,
+            ...tagCodeArtifacts({
+                channelType,
+                channelId,
+                fluidDataStoreId: this.id,
+                fluidDataStorePackagePath: this.dataStoreContext.packagePath.join("/"),
+            }),
+            stack: generateStack(),
+        });
+        this.localChangesTelemetryCount--;
+    }
 }
 /**
  * Mixin class that adds request handler to 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
  */
 export const mixinRequestHandler = (requestHandler, Base = FluidDataStoreRuntime) => class RuntimeWithRequestHandler extends Base {
     async request(request) {
@@ -712,6 +782,7 @@ export const mixinRequestHandler = (requestHandler, Base = FluidDataStoreRuntime
  * @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
  */
 export const mixinSummaryHandler = (handler, Base = FluidDataStoreRuntime) => class RuntimeWithSummarizerHandler extends Base {
     addBlob(summary, path, content) {
@@ -736,11 +807,17 @@ export const mixinSummaryHandler = (handler, Base = FluidDataStoreRuntime) => cl
     }
     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 DataProcessingError.wrapIfUnrecognized(e, "mixinSummaryHandler");
         }
         return summary;
     }
 };
-//# sourceMappingURL=dataStoreRuntime.js.map
+//# sourceMappingURL=dataStoreRuntime.mjs.map