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

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

@@ -6,72 +6,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalDetachedFluidDataStoreContext = exports.LocalFluidDataStoreContext = exports.LocalFluidDataStoreContextBase = exports.RemoteFluidDataStoreContext = exports.FluidDataStoreContext = exports.createAttributesBlob = void 0;
 const container_definitions_1 = require("@fluidframework/container-definitions");
-const common_utils_1 = require("@fluidframework/common-utils");
+const client_utils_1 = require("@fluid-internal/client-utils");
+const core_utils_1 = require("@fluidframework/core-utils");
 const driver_utils_1 = require("@fluidframework/driver-utils");
-const protocol_base_1 = require("@fluidframework/protocol-base");
 const runtime_definitions_1 = require("@fluidframework/runtime-definitions");
 const runtime_utils_1 = require("@fluidframework/runtime-utils");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
-const container_utils_1 = require("@fluidframework/container-utils");
-const summaryFormat_1 = require("./summaryFormat");
-function createAttributes(pkg, isRootDataStore, disableIsolatedChannels) {
+const summary_1 = require("./summary/index.cjs");
+const gc_1 = require("./gc/index.cjs");
+function createAttributes(pkg, isRootDataStore) {
     const stringifiedPkg = JSON.stringify(pkg);
-    return disableIsolatedChannels ? {
-        pkg: stringifiedPkg,
-        snapshotFormatVersion: "0.1",
-        isRootDataStore,
-    } : {
+    return {
         pkg: stringifiedPkg,
         summaryFormatVersion: 2,
         isRootDataStore,
     };
 }
-function createAttributesBlob(pkg, isRootDataStore, disableIsolatedChannels) {
-    const attributes = createAttributes(pkg, isRootDataStore, disableIsolatedChannels);
-    return new protocol_base_1.BlobTreeEntry(summaryFormat_1.dataStoreAttributesBlobName, JSON.stringify(attributes));
+function createAttributesBlob(pkg, isRootDataStore) {
+    const attributes = createAttributes(pkg, isRootDataStore);
+    return new driver_utils_1.BlobTreeEntry(summary_1.dataStoreAttributesBlobName, JSON.stringify(attributes));
 }
 exports.createAttributesBlob = createAttributesBlob;
 /**
  * Represents the context for the store. This context is passed to the store runtime.
  */
-class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
-    constructor(props, existing, bindState, isLocalDataStore, makeLocallyVisibleFn) {
-        super();
-        this.existing = existing;
-        this.bindState = bindState;
-        this.isLocalDataStore = isLocalDataStore;
-        this.makeLocallyVisibleFn = makeLocallyVisibleFn;
-        this._disposed = false;
-        this.detachedRuntimeCreation = false;
-        this.loaded = false;
-        this.pending = [];
-        this._isInMemoryRoot = false;
-        this._containerRuntime = props.runtime;
-        this.id = props.id;
-        this.storage = props.storage;
-        this.scope = props.scope;
-        this.writeGCDataAtRoot = props.writeGCDataAtRoot;
-        this.disableIsolatedChannels = props.disableIsolatedChannels;
-        this.pkg = props.pkg;
-        // URIs use slashes as delimiters. Handles use URIs.
-        // Thus having slashes in types almost guarantees trouble down the road!
-        (0, common_utils_1.assert)(!this.id.includes("/"), 0x13a /* Data store ID contains slash */);
-        this._attachState = this.containerRuntime.attachState !== container_definitions_1.AttachState.Detached && this.existing ?
-            this.containerRuntime.attachState : container_definitions_1.AttachState.Detached;
-        this.bindToContext = () => {
-            (0, common_utils_1.assert)(this.bindState === container_definitions_1.BindState.NotBound, 0x13b /* "datastore context is already in bound state" */);
-            this.bindState = container_definitions_1.BindState.Binding;
-            (0, common_utils_1.assert)(this.channel !== undefined, 0x13c /* "undefined channel on datastore context" */);
-            this.makeLocallyVisible();
-            this.bindState = container_definitions_1.BindState.Bound;
-        };
-        const thisSummarizeInternal = async (fullTree, trackState, telemetryContext) => this.summarizeInternal(fullTree, trackState, telemetryContext);
-        this.summarizerNode = props.createSummarizerNodeFn(thisSummarizeInternal, async (fullGC) => this.getGCDataInternal(fullGC), async () => this.getBaseGCDetails());
-        this.subLogger = telemetry_utils_1.ChildLogger.create(this.logger, "FluidDataStoreContext");
-        this.thresholdOpsCounter = new telemetry_utils_1.ThresholdCounter(FluidDataStoreContext.pendingOpsCountThreshold, this.subLogger);
-    }
+class FluidDataStoreContext extends client_utils_1.TypedEventEmitter {
     get packagePath() {
-        (0, common_utils_1.assert)(this.pkg !== undefined, 0x139 /* "Undefined package path" */);
+        (0, core_utils_1.assert)(this.pkg !== undefined, 0x139 /* "Undefined package path" */);
         return this.pkg;
     }
     get options() {
@@ -98,13 +59,24 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
     get containerRuntime() {
         return this._containerRuntime;
     }
+    ensureNoDataModelChanges(callback) {
+        return this._containerRuntime.ensureNoDataModelChanges(callback);
+    }
     get isLoaded() {
         return this.loaded;
     }
     get baseSnapshot() {
         return this._baseSnapshot;
     }
-    get disposed() { return this._disposed; }
+    get idCompressor() {
+        return this._containerRuntime.idCompressor;
+    }
+    get disposed() {
+        return this._disposed;
+    }
+    get tombstoned() {
+        return this._tombstoned;
+    }
     get attachState() {
         return this._attachState;
     }
@@ -130,6 +102,55 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
     isInMemoryRoot() {
         return this._isInMemoryRoot;
     }
+    constructor(props, existing, isLocalDataStore, makeLocallyVisibleFn) {
+        super();
+        this.existing = existing;
+        this.isLocalDataStore = isLocalDataStore;
+        this.makeLocallyVisibleFn = makeLocallyVisibleFn;
+        this._disposed = false;
+        /**
+         * A Tombstoned object has been unreferenced long enough that GC knows it won't be referenced again.
+         * Tombstoned objects are eventually deleted by GC.
+         */
+        this._tombstoned = false;
+        /** If true, this means that this data store context and its children have been removed from the runtime */
+        this.deleted = false;
+        this.detachedRuntimeCreation = false;
+        this.loaded = false;
+        this.pending = [];
+        this._isInMemoryRoot = false;
+        this._containerRuntime = props.runtime;
+        this.id = props.id;
+        this.storage = props.storage;
+        this.scope = props.scope;
+        this.pkg = props.pkg;
+        // URIs use slashes as delimiters. Handles use URIs.
+        // Thus having slashes in types almost guarantees trouble down the road!
+        (0, core_utils_1.assert)(!this.id.includes("/"), 0x13a /* Data store ID contains slash */);
+        this._attachState =
+            this.containerRuntime.attachState !== container_definitions_1.AttachState.Detached && this.existing
+                ? this.containerRuntime.attachState
+                : container_definitions_1.AttachState.Detached;
+        const thisSummarizeInternal = async (fullTree, trackState, telemetryContext) => this.summarizeInternal(fullTree, trackState, telemetryContext);
+        this.summarizerNode = props.createSummarizerNodeFn(thisSummarizeInternal, async (fullGC) => this.getGCDataInternal(fullGC));
+        this.mc = (0, telemetry_utils_1.createChildMonitoringContext)({
+            logger: this.logger,
+            namespace: "FluidDataStoreContext",
+            properties: {
+                all: (0, telemetry_utils_1.tagCodeArtifacts)({
+                    fluidDataStoreId: this.id,
+                    // The package name is a getter because `this.pkg` may not be initialized during construction.
+                    // For data stores loaded from summary, it is initialized during data store realization.
+                    fullPackageName: () => this.pkg?.join("/"),
+                }),
+            },
+        });
+        this.thresholdOpsCounter = new telemetry_utils_1.ThresholdCounter(FluidDataStoreContext.pendingOpsCountThreshold, this.mc.logger);
+        this.throwOnTombstoneUsage = this._containerRuntime.gcThrowOnTombstoneUsage;
+        // By default, a data store can log maximum 10 local changes telemetry in summarizer.
+        this.localChangesTelemetryCount =
+            this.mc.config.getNumber("Fluid.Telemetry.LocalChangesTelemetryCount") ?? 10;
+    }
     dispose() {
         if (this._disposed) {
             return;
@@ -138,30 +159,51 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
         // Dispose any pending runtime after it gets fulfilled
         // Errors are logged where this.channelDeferred is consumed/generated (realizeCore(), bindRuntime())
         if (this.channelDeferred) {
-            this.channelDeferred.promise.then((runtime) => {
+            this.channelDeferred.promise
+                .then((runtime) => {
                 runtime.dispose();
-            }).catch((error) => { });
+            })
+                .catch((error) => { });
         }
     }
-    rejectDeferredRealize(reason, packageName) {
-        throw new telemetry_utils_1.LoggingError(reason, { packageName: { value: packageName, tag: telemetry_utils_1.TelemetryDataTag.PackageData } });
+    /**
+     * When delete is called, that means that the data store is permanently removed from the runtime, and will not show up in future summaries
+     * This function is called to prevent ops from being generated from this data store once it has been deleted. Furthermore, this data store
+     * should not receive any ops/signals.
+     */
+    delete() {
+        this.deleted = true;
+    }
+    setTombstone(tombstone) {
+        if (this.tombstoned === tombstone) {
+            return;
+        }
+        this._tombstoned = tombstone;
+    }
+    rejectDeferredRealize(reason, failedPkgPath, fullPackageName) {
+        throw new telemetry_utils_1.LoggingError(reason, (0, telemetry_utils_1.tagCodeArtifacts)({
+            failedPkgPath,
+            packagePath: fullPackageName?.join("/"),
+        }));
     }
     async realize() {
-        (0, common_utils_1.assert)(!this.detachedRuntimeCreation, 0x13d /* "Detached runtime creation on realize()" */);
+        (0, core_utils_1.assert)(!this.detachedRuntimeCreation, 0x13d /* "Detached runtime creation on realize()" */);
         if (!this.channelDeferred) {
-            this.channelDeferred = new common_utils_1.Deferred();
+            this.channelDeferred = new core_utils_1.Deferred();
             this.realizeCore(this.existing).catch((error) => {
-                var _a;
-                const errorWrapped = container_utils_1.DataProcessingError.wrapIfUnrecognized(error, "realizeFluidDataStoreContext");
-                errorWrapped.addTelemetryProperties({ fluidDataStoreId: { value: this.id, tag: "PackageData" } });
-                (_a = this.channelDeferred) === null || _a === void 0 ? void 0 : _a.reject(errorWrapped);
-                this.logger.sendErrorEvent({ eventName: "RealizeError" }, errorWrapped);
+                const errorWrapped = telemetry_utils_1.DataProcessingError.wrapIfUnrecognized(error, "realizeFluidDataStoreContext");
+                errorWrapped.addTelemetryProperties((0, telemetry_utils_1.tagCodeArtifacts)({
+                    fullPackageName: this.pkg?.join("/"),
+                    fluidDataStoreId: this.id,
+                }));
+                this.channelDeferred?.reject(errorWrapped);
+                this.mc.logger.sendErrorEvent({ eventName: "RealizeError" }, errorWrapped);
             });
         }
         return this.channelDeferred.promise;
     }
     async factoryFromPackagePath(packages) {
-        (0, common_utils_1.assert)(this.pkg === packages, 0x13e /* "Unexpected package path" */);
+        (0, core_utils_1.assert)(this.pkg === packages, 0x13e /* "Unexpected package path" */);
         if (packages === undefined) {
             this.rejectDeferredRealize("packages is undefined");
         }
@@ -170,18 +212,18 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
         let lastPkg;
         for (const pkg of packages) {
             if (!registry) {
-                this.rejectDeferredRealize("No registry for package", lastPkg);
+                this.rejectDeferredRealize("No registry for package", lastPkg, packages);
             }
             lastPkg = pkg;
             entry = await registry.get(pkg);
             if (!entry) {
-                this.rejectDeferredRealize("Registry does not contain entry for the package", pkg);
+                this.rejectDeferredRealize("Registry does not contain entry for the package", pkg, packages);
             }
             registry = entry.IFluidDataStoreRegistry;
         }
-        const factory = entry === null || entry === void 0 ? void 0 : entry.IFluidDataStoreFactory;
+        const factory = entry?.IFluidDataStoreFactory;
         if (factory === undefined) {
-            this.rejectDeferredRealize("Can't find factory for package", lastPkg);
+            this.rejectDeferredRealize("Can't find factory for package", lastPkg, packages);
         }
         return { factory, registry };
     }
@@ -193,52 +235,66 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
         this._baseSnapshot = details.snapshot;
         const packages = details.pkg;
         const { factory, registry } = await this.factoryFromPackagePath(packages);
-        (0, common_utils_1.assert)(this.registry === undefined, 0x13f /* "datastore context registry is already set" */);
+        (0, core_utils_1.assert)(this.registry === undefined, 0x13f /* "datastore context registry is already set" */);
         this.registry = registry;
         const channel = await factory.instantiateDataStore(this, existing);
-        (0, common_utils_1.assert)(channel !== undefined, 0x140 /* "undefined channel on datastore context" */);
+        (0, core_utils_1.assert)(channel !== undefined, 0x140 /* "undefined channel on datastore context" */);
         this.bindRuntime(channel);
+        // This data store may have been disposed before the channel is created during realization. If so,
+        // dispose the channel now.
+        if (this.disposed) {
+            channel.dispose();
+        }
     }
     /**
      * Notifies this object about changes in the connection state.
      * @param value - New connection state.
-     * @param clientId - ID of the client. It's old ID when in disconnected state and
-     * it's new client ID when we are connecting or connected.
+     * @param clientId - ID of the client. Its old ID when in disconnected state and
+     * its new client ID when we are connecting or connected.
      */
     setConnectionState(connected, clientId) {
-        this.verifyNotClosed();
+        // ConnectionState should not fail in tombstone mode as this is internally run
+        this.verifyNotClosed("setConnectionState", false /* checkTombstone */);
         // Connection events are ignored if the store is not yet loaded
         if (!this.loaded) {
             return;
         }
-        (0, common_utils_1.assert)(this.connected === connected, 0x141 /* "Unexpected connected state" */);
+        (0, core_utils_1.assert)(this.connected === connected, 0x141 /* "Unexpected connected state" */);
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         this.channel.setConnectionState(connected, clientId);
     }
     process(messageArg, local, localOpMetadata) {
-        var _a;
-        this.verifyNotClosed();
+        const safeTelemetryProps = (0, telemetry_utils_1.extractSafePropertiesFromMessage)(messageArg);
+        // On op process, tombstone error is logged in garbage collector. So, set "checkTombstone" to false when calling
+        // "verifyNotClosed" which logs tombstone errors. Throw error if tombstoned and throwing on load is configured.
+        this.verifyNotClosed("process", false /* checkTombstone */, safeTelemetryProps);
+        if (this.tombstoned && this.throwOnTombstoneUsage) {
+            throw new telemetry_utils_1.DataCorruptionError("Context is tombstoned! Call site [process]", safeTelemetryProps);
+        }
         const innerContents = messageArg.contents;
-        const message = Object.assign(Object.assign({}, messageArg), { type: innerContents.type, contents: innerContents.content });
+        const message = {
+            ...messageArg,
+            type: innerContents.type,
+            contents: innerContents.content,
+        };
         this.summarizerNode.recordChange(message);
         if (this.loaded) {
-            return (_a = this.channel) === null || _a === void 0 ? void 0 : _a.process(message, local, localOpMetadata);
+            return this.channel?.process(message, local, localOpMetadata);
         }
         else {
-            (0, common_utils_1.assert)(!local, 0x142 /* "local store channel is not loaded" */);
-            (0, common_utils_1.assert)(this.pending !== undefined, 0x23d /* "pending is undefined" */);
+            (0, core_utils_1.assert)(!local, 0x142 /* "local store channel is not loaded" */);
+            (0, core_utils_1.assert)(this.pending !== undefined, 0x23d /* "pending is undefined" */);
             this.pending.push(message);
             this.thresholdOpsCounter.sendIfMultiple("StorePendingOps", this.pending.length);
         }
     }
     processSignal(message, local) {
-        var _a;
-        this.verifyNotClosed();
+        this.verifyNotClosed("processSignal");
         // Signals are ignored if the store is not yet loaded
         if (!this.loaded) {
             return;
         }
-        (_a = this.channel) === null || _a === void 0 ? void 0 : _a.processSignal(message, local);
+        this.channel?.processSignal(message, local);
     }
     getQuorum() {
         return this._containerRuntime.getQuorum();
@@ -259,28 +315,25 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
         await this.realize();
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const summarizeResult = await this.channel.summarize(fullTree, trackState, telemetryContext);
-        let pathPartsForChildren;
-        if (!this.disableIsolatedChannels) {
-            // Wrap dds summaries in .channels subtree.
-            (0, summaryFormat_1.wrapSummaryInChannelsTree)(summarizeResult);
-            pathPartsForChildren = [runtime_definitions_1.channelsTreeName];
-        }
+        // Wrap dds summaries in .channels subtree.
+        (0, summary_1.wrapSummaryInChannelsTree)(summarizeResult);
+        const pathPartsForChildren = [runtime_definitions_1.channelsTreeName];
         // Add data store's attributes to the summary.
         const { pkg } = await this.getInitialSnapshotDetails();
         const isRoot = await this.isRoot();
-        const attributes = createAttributes(pkg, isRoot, this.disableIsolatedChannels);
-        (0, runtime_utils_1.addBlobToSummary)(summarizeResult, summaryFormat_1.dataStoreAttributesBlobName, JSON.stringify(attributes));
-        // Add GC data to the summary if it's not written at the root.
-        if (!this.writeGCDataAtRoot) {
-            (0, runtime_utils_1.addBlobToSummary)(summarizeResult, runtime_definitions_1.gcBlobKey, JSON.stringify(this.summarizerNode.getGCSummaryDetails()));
-        }
+        const attributes = createAttributes(pkg, isRoot);
+        (0, runtime_utils_1.addBlobToSummary)(summarizeResult, summary_1.dataStoreAttributesBlobName, JSON.stringify(attributes));
         // If we are not referenced, mark the summary tree as unreferenced. Also, update unreferenced blob
         // size in the summary stats with the blobs size of this data store.
         if (!this.summarizerNode.isReferenced()) {
             summarizeResult.summary.unreferenced = true;
             summarizeResult.stats.unreferencedBlobSize = summarizeResult.stats.totalBlobSize;
         }
-        return Object.assign(Object.assign({}, summarizeResult), { id: this.id, pathPartsForChildren });
+        return {
+            ...summarizeResult,
+            id: this.id,
+            pathPartsForChildren,
+        };
     }
     /**
      * Returns the data used for garbage collection. This includes a list of GC nodes that represent this data store
@@ -300,32 +353,34 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
      */
     async getGCDataInternal(fullGC = false) {
         await this.realize();
-        (0, common_utils_1.assert)(this.channel !== undefined, 0x143 /* "Channel should not be undefined when running GC" */);
+        (0, core_utils_1.assert)(this.channel !== undefined, 0x143 /* "Channel should not be undefined when running GC" */);
         return this.channel.getGCData(fullGC);
     }
     /**
      * After GC has run, called to notify the data store of routes used in it. These are used for the following:
+     *
      * 1. To identify if this data store is being referenced in the document or not.
+     *
      * 2. To determine if it needs to re-summarize in case used routes changed since last summary.
+     *
      * 3. These are added to the summary generated by the data store.
-     * 4. To notify child contexts of their used routes. This is done immediately if the data store is loaded. Else,
-     *    it is done when realizing the data store.
+     *
+     * 4. To notify child contexts of their used routes. This is done immediately if the data store is loaded.
+     * Else, it is done when realizing the data store.
+     *
      * 5. To update the timestamp when this data store or any children are marked as unreferenced.
+     *
      * @param usedRoutes - The routes that are used in this data store.
-     * @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) {
+    updateUsedRoutes(usedRoutes) {
         // Update the used routes in this data store's summarizer node.
-        this.summarizerNode.updateUsedRoutes(usedRoutes, gcTimestamp);
+        this.summarizerNode.updateUsedRoutes(usedRoutes);
         /**
-         * If the data store has not been realized yet, we need this used state to update the used state of the channel
-         * when it realizes. It's safe to keep only the last used state because if something changes because of this GC
-         * run, the data store will be immediately realized as part of the summary that follows GC. For example, if a
-         * child's reference state changes, the gcTimestamp has to be used to update its unreferencedTimestamp. Since
-         * it will result in a change in this data store's used routes, it will be realized to regenerate its summary.
+         * Store the used routes to update the channel if the data store is not loaded yet. If the used routes changed
+         * since the previous run, the data store will be loaded during summarize since the used state changed. So, it's
+         * safe to only store the last used routes.
          */
-        this.lastUsedState = { usedRoutes, gcTimestamp };
+        this.lastUsedRoutes = usedRoutes;
         // If we are loaded, call the channel so it can update the used routes of the child contexts.
         // If we are not loaded, we will update this when we are realized.
         if (this.loaded) {
@@ -348,15 +403,17 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
      * 2. When the data store is realized. This updates the channel's used routes as per last GC run.
      */
     updateChannelUsedRoutes() {
-        (0, common_utils_1.assert)(this.loaded, 0x144 /* "Channel should be loaded when updating used routes" */);
-        (0, common_utils_1.assert)(this.channel !== undefined, 0x145 /* "Channel should be present when data store is loaded" */);
-        // If there is no lastUsedState, GC has not run up until this point.
-        if (this.lastUsedState === undefined) {
+        (0, core_utils_1.assert)(this.loaded, 0x144 /* "Channel should be loaded when updating used routes" */);
+        (0, core_utils_1.assert)(this.channel !== undefined, 0x145 /* "Channel should be present when data store is loaded" */);
+        // If there is no lastUsedRoutes, GC has not run up until this point.
+        if (this.lastUsedRoutes === undefined) {
             return;
         }
         // Remove the route to this data store, if it exists.
-        const usedChannelRoutes = this.lastUsedState.usedRoutes.filter((id) => { return id !== "/" && id !== ""; });
-        this.channel.updateUsedRoutes(usedChannelRoutes, this.lastUsedState.gcTimestamp);
+        const usedChannelRoutes = this.lastUsedRoutes.filter((id) => {
+            return id !== "/" && id !== "";
+        });
+        this.channel.updateUsedRoutes(usedChannelRoutes);
     }
     /**
      * @deprecated 0.18.Should call request on the runtime directly
@@ -366,12 +423,14 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
         return runtime.request(request);
     }
     submitMessage(type, content, localOpMetadata) {
-        this.verifyNotClosed();
-        (0, common_utils_1.assert)(!!this.channel, 0x146 /* "Channel must exist when submitting message" */);
+        this.verifyNotClosed("submitMessage");
+        (0, core_utils_1.assert)(!!this.channel, 0x146 /* "Channel must exist when submitting message" */);
         const fluidDataStoreContent = {
             content,
             type,
         };
+        // Summarizer clients should not submit messages.
+        this.identifyLocalChangeInSummarizer("DataStoreMessageSubmittedInSummarizer", type);
         this._containerRuntime.submitDataStoreOp(this.id, fluidDataStoreContent, localOpMetadata);
     }
     /**
@@ -384,7 +443,7 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
      *
      */
     setChannelDirty(address) {
-        this.verifyNotClosed();
+        this.verifyNotClosed("setChannelDirty");
         // Get the latest sequence number.
         const latestSequenceNumber = this.deltaManager.lastSequenceNumber;
         this.summarizerNode.invalidate(latestSequenceNumber);
@@ -393,28 +452,34 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
             channelSummarizerNode.invalidate(latestSequenceNumber); // TODO: lazy load problem?
         }
     }
-    submitSignal(type, content) {
-        this.verifyNotClosed();
-        (0, common_utils_1.assert)(!!this.channel, 0x147 /* "Channel must exist on submitting signal" */);
-        return this._containerRuntime.submitDataStoreSignal(this.id, 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("submitSignal");
+        (0, core_utils_1.assert)(!!this.channel, 0x147 /* "Channel must exist on submitting signal" */);
+        return this._containerRuntime.submitDataStoreSignal(this.id, type, content, targetClientId);
     }
     /**
      * This is called by the data store channel when it becomes locally visible indicating that it is ready to become
      * globally visible now.
      */
     makeLocallyVisible() {
-        (0, common_utils_1.assert)(this.channel !== undefined, 0x2cf /* "undefined channel on datastore context" */);
+        (0, core_utils_1.assert)(this.channel !== undefined, 0x2cf /* "undefined channel on datastore context" */);
+        (0, core_utils_1.assert)(this.channel.visibilityState === runtime_definitions_1.VisibilityState.LocallyVisible, 0x590 /* Channel must be locally visible */);
         this.makeLocallyVisibleFn();
     }
     bindRuntime(channel) {
-        var _a;
         if (this.channel) {
             throw new Error("Runtime already bound");
         }
         try {
-            (0, common_utils_1.assert)(!this.detachedRuntimeCreation, 0x148 /* "Detached runtime creation on runtime bind" */);
-            (0, common_utils_1.assert)(this.channelDeferred !== undefined, 0x149 /* "Undefined channel deferral" */);
-            (0, common_utils_1.assert)(this.pkg !== undefined, 0x14a /* "Undefined package path" */);
+            (0, core_utils_1.assert)(!this.detachedRuntimeCreation, 0x148 /* "Detached runtime creation on runtime bind" */);
+            (0, core_utils_1.assert)(this.channelDeferred !== undefined, 0x149 /* "Undefined channel deferral" */);
+            (0, core_utils_1.assert)(this.pkg !== undefined, 0x14a /* "Undefined package path" */);
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const pending = this.pending;
             // Apply all pending ops
@@ -441,8 +506,10 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
             this.channelDeferred.resolve(this.channel);
         }
         catch (error) {
-            (_a = this.channelDeferred) === null || _a === void 0 ? void 0 : _a.reject(error);
-            this.logger.sendErrorEvent({ eventName: "BindRuntimeError", fluidDataStoreId: { value: this.id, tag: "PackageData" } }, error);
+            this.channelDeferred?.reject(error);
+            this.mc.logger.sendErrorEvent({
+                eventName: "BindRuntimeError",
+            }, error);
         }
     }
     async getAbsoluteUrl(relativeUrl) {
@@ -452,15 +519,21 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
         return this._containerRuntime.getAbsoluteUrl(relativeUrl);
     }
     /**
-     * @deprecated - Sets the datastore as root, for aliasing purposes: #7948
+     * @deprecated Sets the datastore as root, for aliasing purposes: #7948
      * This method should not be used outside of the aliasing context.
      * It will be removed, as the source of truth for this flag will be the aliasing blob.
      */
     setInMemoryRoot() {
         this._isInMemoryRoot = true;
     }
+    /**
+     * @deprecated The functionality to get base GC details has been moved to summarizer node.
+     */
+    async getBaseGCDetails() {
+        return {};
+    }
     reSubmit(contents, localOpMetadata) {
-        (0, common_utils_1.assert)(!!this.channel, 0x14b /* "Channel must exist when resubmitting ops" */);
+        (0, core_utils_1.assert)(!!this.channel, 0x14b /* "Channel must exist when resubmitting ops" */);
         const innerContents = contents;
         this.channel.reSubmit(innerContents.type, innerContents.content, localOpMetadata);
     }
@@ -478,64 +551,88 @@ class FluidDataStoreContext extends common_utils_1.TypedEventEmitter {
         if (!this.channel) {
             await this.realize();
         }
-        (0, common_utils_1.assert)(!!this.channel, 0x14c /* "Channel must exist when rebasing ops" */);
-        const innerContents = contents;
-        return this.channel.applyStashedOp(innerContents.content);
-    }
-    verifyNotClosed() {
+        (0, core_utils_1.assert)(!!this.channel, 0x14c /* "Channel must exist when rebasing ops" */);
+        return this.channel.applyStashedOp(contents);
+    }
+    verifyNotClosed(callSite, checkTombstone = true, safeTelemetryProps = {}) {
+        if (this.deleted) {
+            const messageString = `Context is deleted! Call site [${callSite}]`;
+            const error = new telemetry_utils_1.DataCorruptionError(messageString, safeTelemetryProps);
+            this.mc.logger.sendErrorEvent({
+                eventName: "GC_Deleted_DataStore_Changed",
+                callSite,
+            }, error);
+            throw error;
+        }
         if (this._disposed) {
-            throw new Error("Context is closed");
+            throw new Error(`Context is closed! Call site [${callSite}]`);
+        }
+        if (checkTombstone && this.tombstoned) {
+            const messageString = `Context is tombstoned! Call site [${callSite}]`;
+            const error = new telemetry_utils_1.DataCorruptionError(messageString, safeTelemetryProps);
+            (0, gc_1.sendGCUnexpectedUsageEvent)(this.mc, {
+                eventName: "GC_Tombstone_DataStore_Changed",
+                category: this.throwOnTombstoneUsage ? "error" : "generic",
+                gcTombstoneEnforcementAllowed: this._containerRuntime.gcTombstoneEnforcementAllowed,
+                callSite,
+            }, this.pkg, error);
+            if (this.throwOnTombstoneUsage) {
+                throw error;
+            }
+        }
+    }
+    /**
+     * 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, type) {
+        if (this.clientDetails.type !== summary_1.summarizerClientType ||
+            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,
+            type,
+            isSummaryInProgress: this.summarizerNode.isSummaryInProgress?.(),
+            stack: (0, telemetry_utils_1.generateStack)(),
+        });
+        this.localChangesTelemetryCount--;
     }
     getCreateChildSummarizerNodeFn(id, createParam) {
-        return (summarizeInternal, getGCDataFn, getBaseGCDetailsFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, 
+        return (summarizeInternal, getGCDataFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, 
         // DDS will not create failure summaries
-        { throwOnFailure: true }, getGCDataFn, getBaseGCDetailsFn);
+        { throwOnFailure: true }, getGCDataFn);
     }
-    async uploadBlob(blob) {
-        return this.containerRuntime.uploadBlob(blob);
+    async uploadBlob(blob, signal) {
+        return this.containerRuntime.uploadBlob(blob, signal);
     }
 }
 exports.FluidDataStoreContext = FluidDataStoreContext;
 FluidDataStoreContext.pendingOpsCountThreshold = 1000;
 class RemoteFluidDataStoreContext extends FluidDataStoreContext {
     constructor(props) {
-        super(props, true /* existing */, container_definitions_1.BindState.Bound, false /* isLocalDataStore */, () => {
+        super(props, true /* existing */, false /* isLocalDataStore */, () => {
             throw new Error("Already attached");
         });
-        this.initialSnapshotDetailsP = new common_utils_1.LazyPromise(async () => {
-            var _a, _b;
-            let tree;
+        this.initialSnapshotDetailsP = new core_utils_1.LazyPromise(async () => {
+            let tree = this.initSnapshotValue;
             let isRootDataStore = true;
-            if (typeof this.initSnapshotValue === "string") {
-                const commit = (await this.storage.getVersions(this.initSnapshotValue, 1))[0];
-                tree = (_a = await this.storage.getSnapshotTree(commit)) !== null && _a !== void 0 ? _a : undefined;
-            }
-            else {
-                tree = this.initSnapshotValue;
-            }
-            const localReadAndParse = async (id) => (0, driver_utils_1.readAndParse)(this.storage, id);
-            if (tree) {
-                const loadedSummary = await this.summarizerNode.loadBaseSummary(tree, localReadAndParse);
-                tree = loadedSummary.baseSummary;
-                // Prepend outstanding ops to pending queue of ops to process.
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                this.pending = loadedSummary.outstandingOps.concat(this.pending);
-            }
-            if (!!tree && tree.blobs[summaryFormat_1.dataStoreAttributesBlobName] !== undefined) {
+            if (!!tree && tree.blobs[summary_1.dataStoreAttributesBlobName] !== undefined) {
                 // Need to get through snapshot and use that to populate extraBlobs
-                const attributes = await localReadAndParse(tree.blobs[summaryFormat_1.dataStoreAttributesBlobName]);
+                const attributes = await (0, driver_utils_1.readAndParse)(this.storage, tree.blobs[summary_1.dataStoreAttributesBlobName]);
                 let pkgFromSnapshot;
                 // Use the snapshotFormatVersion to determine how the pkg is encoded in the snapshot.
                 // For snapshotFormatVersion = "0.1" (1) or above, pkg is jsonified, otherwise it is just a string.
-                const formatVersion = (0, summaryFormat_1.getAttributesFormatVersion)(attributes);
+                const formatVersion = (0, summary_1.getAttributesFormatVersion)(attributes);
                 if (formatVersion < 1) {
-                    if (attributes.pkg.startsWith("[\"") && attributes.pkg.endsWith("\"]")) {
-                        pkgFromSnapshot = JSON.parse(attributes.pkg);
-                    }
-                    else {
-                        pkgFromSnapshot = [attributes.pkg];
-                    }
+                    pkgFromSnapshot =
+                        attributes.pkg.startsWith('["') && attributes.pkg.endsWith('"]')
+                            ? JSON.parse(attributes.pkg)
+                            : [attributes.pkg];
                 }
                 else {
                     pkgFromSnapshot = JSON.parse(attributes.pkg);
@@ -546,10 +643,10 @@ class RemoteFluidDataStoreContext extends FluidDataStoreContext {
                  * data stores in older documents are not garbage collected incorrectly. This may lead to additional
                  * roots in the document but they won't break.
                  */
-                isRootDataStore = (_b = attributes.isRootDataStore) !== null && _b !== void 0 ? _b : true;
-                if ((0, summaryFormat_1.hasIsolatedChannels)(attributes)) {
+                isRootDataStore = attributes.isRootDataStore ?? true;
+                if ((0, summary_1.hasIsolatedChannels)(attributes)) {
                     tree = tree.trees[runtime_definitions_1.channelsTreeName];
-                    (0, common_utils_1.assert)(tree !== undefined, 0x1fe /* "isolated channels subtree should exist in remote datastore snapshot" */);
+                    (0, core_utils_1.assert)(tree !== undefined, 0x1fe /* "isolated channels subtree should exist in remote datastore snapshot" */);
                 }
             }
             return {
@@ -560,23 +657,13 @@ class RemoteFluidDataStoreContext extends FluidDataStoreContext {
             };
         });
         this.initSnapshotValue = props.snapshotTree;
-        this.baseGCDetailsP = new common_utils_1.LazyPromise(async () => {
-            var _a;
-            return (_a = (await props.getBaseGCDetails())) !== null && _a !== void 0 ? _a : {};
-        });
+        if (props.snapshotTree !== undefined) {
+            this.summarizerNode.updateBaseSummaryState(props.snapshotTree);
+        }
     }
     async getInitialSnapshotDetails() {
         return this.initialSnapshotDetailsP;
     }
-    /**
-     * @deprecated - Renamed to getBaseGCDetails.
-     */
-    async getInitialGCSummaryDetails() {
-        return this.getBaseGCDetails();
-    }
-    async getBaseGCDetails() {
-        return this.baseGCDetailsP;
-    }
     generateAttachMessage() {
         throw new Error("Cannot attach remote store");
     }
@@ -587,7 +674,39 @@ exports.RemoteFluidDataStoreContext = RemoteFluidDataStoreContext;
  */
 class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
     constructor(props) {
-        super(props, props.snapshotTree !== undefined ? true : false /* existing */, props.snapshotTree ? container_definitions_1.BindState.Bound : container_definitions_1.BindState.NotBound, true /* isLocalDataStore */, props.makeLocallyVisibleFn);
+        super(props, props.snapshotTree !== undefined ? true : false /* existing */, true /* isLocalDataStore */, props.makeLocallyVisibleFn);
+        this.initialSnapshotDetailsP = new core_utils_1.LazyPromise(async () => {
+            let snapshot = this.snapshotTree;
+            let attributes;
+            let isRootDataStore = false;
+            if (snapshot !== undefined) {
+                // Get the dataStore attributes.
+                // Note: storage can be undefined in special case while detached.
+                attributes = await (0, summary_1.getFluidDataStoreAttributes)(this.storage, snapshot);
+                if ((0, summary_1.hasIsolatedChannels)(attributes)) {
+                    snapshot = snapshot.trees[runtime_definitions_1.channelsTreeName];
+                    (0, core_utils_1.assert)(snapshot !== undefined, 0x1ff /* "isolated channels subtree should exist in local datastore snapshot" */);
+                }
+                if (this.pkg === undefined) {
+                    this.pkg = JSON.parse(attributes.pkg);
+                    // If there is no isRootDataStore in the attributes blob, set it to true. This ensures that data
+                    // stores in older documents are not garbage collected incorrectly. This may lead to additional
+                    // roots in the document but they won't break.
+                    if (attributes.isRootDataStore ?? true) {
+                        isRootDataStore = true;
+                        this.setInMemoryRoot();
+                    }
+                }
+            }
+            (0, core_utils_1.assert)(this.pkg !== undefined, 0x152 /* "pkg should be available in local data store" */);
+            return {
+                pkg: this.pkg,
+                isRootDataStore,
+                snapshot,
+            };
+        });
+        // Summarizer client should not create local data stores.
+        this.identifyLocalChangeInSummarizer("DataStoreCreatedInSummarizer");
         this.snapshotTree = props.snapshotTree;
         if (props.isRootDataStore === true) {
             this.setInMemoryRoot();
@@ -597,25 +716,23 @@ class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
     }
     attachListeners() {
         this.once("attaching", () => {
-            (0, common_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Detached, 0x14d /* "Should move from detached to attaching" */);
+            (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Detached, 0x14d /* "Should move from detached to attaching" */);
             this._attachState = container_definitions_1.AttachState.Attaching;
         });
         this.once("attached", () => {
-            (0, common_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attaching, 0x14e /* "Should move from attaching to attached" */);
+            (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attaching, 0x14e /* "Should move from attaching to attached" */);
             this._attachState = container_definitions_1.AttachState.Attached;
         });
     }
     generateAttachMessage() {
-        (0, common_utils_1.assert)(this.channel !== undefined, 0x14f /* "There should be a channel when generating attach message" */);
-        (0, common_utils_1.assert)(this.pkg !== undefined, 0x150 /* "pkg should be available in local data store context" */);
+        (0, core_utils_1.assert)(this.channel !== undefined, 0x14f /* "There should be a channel when generating attach message" */);
+        (0, core_utils_1.assert)(this.pkg !== undefined, 0x150 /* "pkg should be available in local data store context" */);
         const summarizeResult = this.channel.getAttachSummary();
-        if (!this.disableIsolatedChannels) {
-            // Wrap dds summaries in .channels subtree.
-            (0, summaryFormat_1.wrapSummaryInChannelsTree)(summarizeResult);
-        }
+        // Wrap dds summaries in .channels subtree.
+        (0, summary_1.wrapSummaryInChannelsTree)(summarizeResult);
         // Add data store's attributes to the summary.
-        const attributes = createAttributes(this.pkg, this.isInMemoryRoot(), this.disableIsolatedChannels);
-        (0, runtime_utils_1.addBlobToSummary)(summarizeResult, summaryFormat_1.dataStoreAttributesBlobName, JSON.stringify(attributes));
+        const attributes = createAttributes(this.pkg, this.isInMemoryRoot());
+        (0, runtime_utils_1.addBlobToSummary)(summarizeResult, summary_1.dataStoreAttributesBlobName, JSON.stringify(attributes));
         // Attach message needs the summary in ITree format. Convert the ISummaryTree into an ITree.
         const snapshot = (0, runtime_utils_1.convertSummaryTreeToITree)(summarizeResult.summary);
         const message = {
@@ -626,46 +743,24 @@ class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
         return message;
     }
     async getInitialSnapshotDetails() {
-        var _a;
-        let snapshot = this.snapshotTree;
-        let attributes;
-        let isRootDataStore = false;
-        if (snapshot !== undefined) {
-            // Get the dataStore attributes.
-            // Note: storage can be undefined in special case while detached.
-            attributes = await (0, summaryFormat_1.getFluidDataStoreAttributes)(this.storage, snapshot);
-            if ((0, summaryFormat_1.hasIsolatedChannels)(attributes)) {
-                snapshot = snapshot.trees[runtime_definitions_1.channelsTreeName];
-                (0, common_utils_1.assert)(snapshot !== undefined, 0x1ff /* "isolated channels subtree should exist in local datastore snapshot" */);
-            }
-            if (this.pkg === undefined) {
-                this.pkg = JSON.parse(attributes.pkg);
-                // If there is no isRootDataStore in the attributes blob, set it to true. This ensures that data
-                // stores in older documents are not garbage collected incorrectly. This may lead to additional
-                // roots in the document but they won't break.
-                if ((_a = attributes.isRootDataStore) !== null && _a !== void 0 ? _a : true) {
-                    isRootDataStore = true;
-                    this.setInMemoryRoot();
-                }
-            }
-        }
-        (0, common_utils_1.assert)(this.pkg !== undefined, 0x152 /* "pkg should be available in local data store" */);
-        return {
-            pkg: this.pkg,
-            isRootDataStore,
-            snapshot,
-        };
+        return this.initialSnapshotDetailsP;
     }
     /**
-     * @deprecated - Renamed to getBaseGCDetails.
+     * A context should only be marked as deleted when its a remote context.
+     * Session Expiry at the runtime level should have closed the container creating the local data store context
+     * before delete is even possible. Session Expiry is at 30 days, and sweep is done 36+ days later from the time
+     * it was unreferenced. Thus the sweeping container should have loaded from a snapshot and thus creating a remote
+     * context.
      */
-    async getInitialGCSummaryDetails() {
-        // Local data store does not have initial summary.
-        return {};
-    }
-    async getBaseGCDetails() {
-        // Local data store does not have initial summary.
-        return {};
+    delete() {
+        // TODO: GC:Validation - potentially prevent this from happening or asserting. Maybe throw here.
+        (0, gc_1.sendGCUnexpectedUsageEvent)(this.mc, {
+            eventName: "GC_Deleted_DataStore_Unexpected_Delete",
+            message: "Unexpected deletion of a local data store context",
+            category: "error",
+            gcTombstoneEnforcementAllowed: undefined,
+        }, this.pkg);
+        super.delete();
     }
 }
 exports.LocalFluidDataStoreContextBase = LocalFluidDataStoreContextBase;
@@ -693,25 +788,26 @@ class LocalDetachedFluidDataStoreContext extends LocalFluidDataStoreContextBase
         this.detachedRuntimeCreation = true;
     }
     async attachRuntime(registry, dataStoreChannel) {
-        (0, common_utils_1.assert)(this.detachedRuntimeCreation, 0x154 /* "runtime creation is already attached" */);
-        (0, common_utils_1.assert)(this.channelDeferred === undefined, 0x155 /* "channel deferral is already set" */);
+        (0, core_utils_1.assert)(this.detachedRuntimeCreation, 0x154 /* "runtime creation is already attached" */);
+        this.detachedRuntimeCreation = false;
+        (0, core_utils_1.assert)(this.channelDeferred === undefined, 0x155 /* "channel deferral is already set" */);
+        this.channelDeferred = new core_utils_1.Deferred();
         const factory = registry.IFluidDataStoreFactory;
         const entry = await this.factoryFromPackagePath(this.pkg);
-        (0, common_utils_1.assert)(entry.factory === factory, 0x156 /* "Unexpected factory for package path" */);
-        (0, common_utils_1.assert)(this.registry === undefined, 0x157 /* "datastore registry already attached" */);
+        (0, core_utils_1.assert)(entry.factory === factory, 0x156 /* "Unexpected factory for package path" */);
+        (0, core_utils_1.assert)(this.registry === undefined, 0x157 /* "datastore registry already attached" */);
         this.registry = entry.registry;
-        this.detachedRuntimeCreation = false;
-        this.channelDeferred = new common_utils_1.Deferred();
         super.bindRuntime(dataStoreChannel);
+        // Load the handle to the data store's entryPoint to make sure that for a detached data store, the entryPoint
+        // initialization function is called before the data store gets attached and potentially connected to the
+        // delta stream, so it gets a chance to do things while the data store is still "purely local".
+        // This preserves the behavior from before we introduced entryPoints, where the instantiateDataStore method
+        // of data store factories tends to construct the data object (at least kick off an async method that returns
+        // it); that code moved to the entryPoint initialization function, so we want to ensure it still executes
+        // before the data store is attached.
+        await dataStoreChannel.entryPoint.get();
         if (await this.isRoot()) {
-            // back-compat 0.59.1000 - makeVisibleAndAttachGraph was added in this version to IFluidDataStoreChannel.
-            // For older versions, we still have to call bindToContext.
-            if (dataStoreChannel.makeVisibleAndAttachGraph !== undefined) {
-                dataStoreChannel.makeVisibleAndAttachGraph();
-            }
-            else {
-                dataStoreChannel.bindToContext();
-            }
+            dataStoreChannel.makeVisibleAndAttachGraph();
         }
     }
     async getInitialSnapshotDetails() {
@@ -722,4 +818,4 @@ class LocalDetachedFluidDataStoreContext extends LocalFluidDataStoreContextBase
     }
 }
 exports.LocalDetachedFluidDataStoreContext = LocalDetachedFluidDataStoreContext;
-//# sourceMappingURL=dataStoreContext.js.map
+//# sourceMappingURL=dataStoreContext.cjs.map