@fluidframework/container-runtime 1.4.0-115997 → 2.0.0-dev-rc.1.0.0.224419

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

@@ -2,70 +2,31 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { BindState, AttachState, } from "@fluidframework/container-definitions";
-import { assert, Deferred, LazyPromise, TypedEventEmitter, } from "@fluidframework/common-utils";
-import { readAndParse } from "@fluidframework/driver-utils";
-import { BlobTreeEntry } from "@fluidframework/protocol-base";
-import { channelsTreeName, gcBlobKey, } from "@fluidframework/runtime-definitions";
+import { AttachState, } from "@fluidframework/container-definitions";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { assert, Deferred, LazyPromise } from "@fluidframework/core-utils";
+import { BlobTreeEntry, readAndParse } from "@fluidframework/driver-utils";
+import { channelsTreeName, VisibilityState, } from "@fluidframework/runtime-definitions";
 import { addBlobToSummary, convertSummaryTreeToITree } from "@fluidframework/runtime-utils";
-import { ChildLogger, LoggingError, TelemetryDataTag, ThresholdCounter, } from "@fluidframework/telemetry-utils";
-import { DataProcessingError } from "@fluidframework/container-utils";
-import { dataStoreAttributesBlobName, hasIsolatedChannels, wrapSummaryInChannelsTree, getAttributesFormatVersion, getFluidDataStoreAttributes, } from "./summaryFormat";
-function createAttributes(pkg, isRootDataStore, disableIsolatedChannels) {
+import { createChildMonitoringContext, DataCorruptionError, DataProcessingError, extractSafePropertiesFromMessage, generateStack, LoggingError, tagCodeArtifacts, ThresholdCounter, } from "@fluidframework/telemetry-utils";
+import { dataStoreAttributesBlobName, hasIsolatedChannels, wrapSummaryInChannelsTree, getAttributesFormatVersion, getFluidDataStoreAttributes, summarizerClientType, } from "./summary/index.mjs";
+import { sendGCUnexpectedUsageEvent } from "./gc/index.mjs";
+function createAttributes(pkg, isRootDataStore) {
     const stringifiedPkg = JSON.stringify(pkg);
-    return disableIsolatedChannels ? {
-        pkg: stringifiedPkg,
-        snapshotFormatVersion: "0.1",
-        isRootDataStore,
-    } : {
+    return {
         pkg: stringifiedPkg,
         summaryFormatVersion: 2,
         isRootDataStore,
     };
 }
-export function createAttributesBlob(pkg, isRootDataStore, disableIsolatedChannels) {
-    const attributes = createAttributes(pkg, isRootDataStore, disableIsolatedChannels);
+export function createAttributesBlob(pkg, isRootDataStore) {
+    const attributes = createAttributes(pkg, isRootDataStore);
     return new BlobTreeEntry(dataStoreAttributesBlobName, JSON.stringify(attributes));
 }
 /**
  * Represents the context for the store. This context is passed to the store runtime.
  */
 export class FluidDataStoreContext extends 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!
-        assert(!this.id.includes("/"), 0x13a /* Data store ID contains slash */);
-        this._attachState = this.containerRuntime.attachState !== AttachState.Detached && this.existing ?
-            this.containerRuntime.attachState : AttachState.Detached;
-        this.bindToContext = () => {
-            assert(this.bindState === BindState.NotBound, 0x13b /* "datastore context is already in bound state" */);
-            this.bindState = BindState.Binding;
-            assert(this.channel !== undefined, 0x13c /* "undefined channel on datastore context" */);
-            this.makeLocallyVisible();
-            this.bindState = 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 = ChildLogger.create(this.logger, "FluidDataStoreContext");
-        this.thresholdOpsCounter = new ThresholdCounter(FluidDataStoreContext.pendingOpsCountThreshold, this.subLogger);
-    }
     get packagePath() {
         assert(this.pkg !== undefined, 0x139 /* "Undefined package path" */);
         return this.pkg;
@@ -94,13 +55,24 @@ export class FluidDataStoreContext extends 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;
     }
@@ -126,6 +98,55 @@ export class FluidDataStoreContext extends TypedEventEmitter {
     isInMemoryRoot() {
         return this._isInMemoryRoot;
     }
+    constructor(props, existing, isLocalDataStore, makeLocallyVisibleFn) {
+        super();
+        this.existing = existing;
+        this.isLocalDataStore = isLocalDataStore;
+        this.makeLocallyVisibleFn = makeLocallyVisibleFn;
+        this._disposed = false;
+        /**
+         * Tombstone is a temporary feature that prevents a data store from sending / receiving ops, signals and from
+         * loading.
+         */
+        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!
+        assert(!this.id.includes("/"), 0x13a /* Data store ID contains slash */);
+        this._attachState =
+            this.containerRuntime.attachState !== AttachState.Detached && this.existing
+                ? this.containerRuntime.attachState
+                : 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 = createChildMonitoringContext({
+            logger: this.logger,
+            namespace: "FluidDataStoreContext",
+            properties: {
+                all: 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 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;
@@ -134,24 +155,45 @@ export class FluidDataStoreContext extends 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 LoggingError(reason, { packageName: { value: packageName, tag: 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 LoggingError(reason, tagCodeArtifacts({
+            failedPkgPath,
+            packagePath: fullPackageName?.join("/"),
+        }));
     }
     async realize() {
         assert(!this.detachedRuntimeCreation, 0x13d /* "Detached runtime creation on realize()" */);
         if (!this.channelDeferred) {
             this.channelDeferred = new Deferred();
             this.realizeCore(this.existing).catch((error) => {
-                var _a;
                 const errorWrapped = 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);
+                errorWrapped.addTelemetryProperties(tagCodeArtifacts({
+                    fullPackageName: this.pkg?.join("/"),
+                    fluidDataStoreId: this.id,
+                }));
+                this.channelDeferred?.reject(errorWrapped);
+                this.mc.logger.sendErrorEvent({ eventName: "RealizeError" }, errorWrapped);
             });
         }
         return this.channelDeferred.promise;
@@ -166,18 +208,18 @@ export class FluidDataStoreContext extends 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 };
     }
@@ -194,15 +236,21 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         const channel = await factory.instantiateDataStore(this, existing);
         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;
@@ -212,13 +260,22 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         this.channel.setConnectionState(connected, clientId);
     }
     process(messageArg, local, localOpMetadata) {
-        var _a;
-        this.verifyNotClosed();
+        const safeTelemetryProps = 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 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 {
             assert(!local, 0x142 /* "local store channel is not loaded" */);
@@ -228,13 +285,12 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         }
     }
     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();
@@ -255,28 +311,25 @@ export class FluidDataStoreContext extends 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.
-            wrapSummaryInChannelsTree(summarizeResult);
-            pathPartsForChildren = [channelsTreeName];
-        }
+        // Wrap dds summaries in .channels subtree.
+        wrapSummaryInChannelsTree(summarizeResult);
+        const pathPartsForChildren = [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);
+        const attributes = createAttributes(pkg, isRoot);
         addBlobToSummary(summarizeResult, dataStoreAttributesBlobName, JSON.stringify(attributes));
-        // Add GC data to the summary if it's not written at the root.
-        if (!this.writeGCDataAtRoot) {
-            addBlobToSummary(summarizeResult, gcBlobKey, JSON.stringify(this.summarizerNode.getGCSummaryDetails()));
-        }
         // 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
@@ -301,27 +354,29 @@ export class FluidDataStoreContext extends TypedEventEmitter {
     }
     /**
      * 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) {
@@ -346,13 +401,15 @@ export class FluidDataStoreContext extends TypedEventEmitter {
     updateChannelUsedRoutes() {
         assert(this.loaded, 0x144 /* "Channel should be loaded when updating used routes" */);
         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) {
+        // 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
@@ -362,12 +419,14 @@ export class FluidDataStoreContext extends TypedEventEmitter {
         return runtime.request(request);
     }
     submitMessage(type, content, localOpMetadata) {
-        this.verifyNotClosed();
+        this.verifyNotClosed("submitMessage");
         assert(!!this.channel, 0x146 /* "Channel must exist when submitting message" */);
         const fluidDataStoreContent = {
             content,
             type,
         };
+        // Summarizer clients should not submit messages.
+        this.identifyLocalChangeInSummarizer("DataStoreMessageSubmittedInSummarizer", type);
         this._containerRuntime.submitDataStoreOp(this.id, fluidDataStoreContent, localOpMetadata);
     }
     /**
@@ -380,7 +439,7 @@ export class FluidDataStoreContext extends TypedEventEmitter {
      *
      */
     setChannelDirty(address) {
-        this.verifyNotClosed();
+        this.verifyNotClosed("setChannelDirty");
         // Get the latest sequence number.
         const latestSequenceNumber = this.deltaManager.lastSequenceNumber;
         this.summarizerNode.invalidate(latestSequenceNumber);
@@ -389,10 +448,16 @@ export class FluidDataStoreContext extends TypedEventEmitter {
             channelSummarizerNode.invalidate(latestSequenceNumber); // TODO: lazy load problem?
         }
     }
-    submitSignal(type, content) {
-        this.verifyNotClosed();
+    /**
+     * 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");
         assert(!!this.channel, 0x147 /* "Channel must exist on submitting signal" */);
-        return this._containerRuntime.submitDataStoreSignal(this.id, type, content);
+        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
@@ -400,10 +465,10 @@ export class FluidDataStoreContext extends TypedEventEmitter {
      */
     makeLocallyVisible() {
         assert(this.channel !== undefined, 0x2cf /* "undefined channel on datastore context" */);
+        assert(this.channel.visibilityState === VisibilityState.LocallyVisible, 0x590 /* Channel must be locally visible */);
         this.makeLocallyVisibleFn();
     }
     bindRuntime(channel) {
-        var _a;
         if (this.channel) {
             throw new Error("Runtime already bound");
         }
@@ -437,8 +502,10 @@ export class FluidDataStoreContext extends 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) {
@@ -448,13 +515,19 @@ export class FluidDataStoreContext extends 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) {
         assert(!!this.channel, 0x14b /* "Channel must exist when resubmitting ops" */);
         const innerContents = contents;
@@ -475,62 +548,86 @@ export class FluidDataStoreContext extends TypedEventEmitter {
             await this.realize();
         }
         assert(!!this.channel, 0x14c /* "Channel must exist when rebasing ops" */);
-        const innerContents = contents;
-        return this.channel.applyStashedOp(innerContents.content);
-    }
-    verifyNotClosed() {
+        return this.channel.applyStashedOp(contents);
+    }
+    verifyNotClosed(callSite, checkTombstone = true, safeTelemetryProps = {}) {
+        if (this.deleted) {
+            const messageString = `Context is deleted! Call site [${callSite}]`;
+            const error = new 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 DataCorruptionError(messageString, safeTelemetryProps);
+            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 !== 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: 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);
     }
 }
 FluidDataStoreContext.pendingOpsCountThreshold = 1000;
 export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
     constructor(props) {
-        super(props, true /* existing */, BindState.Bound, false /* isLocalDataStore */, () => {
+        super(props, true /* existing */, false /* isLocalDataStore */, () => {
             throw new Error("Already attached");
         });
         this.initialSnapshotDetailsP = new LazyPromise(async () => {
-            var _a, _b;
-            let tree;
+            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) => 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[dataStoreAttributesBlobName] !== undefined) {
                 // Need to get through snapshot and use that to populate extraBlobs
-                const attributes = await localReadAndParse(tree.blobs[dataStoreAttributesBlobName]);
+                const attributes = await readAndParse(this.storage, tree.blobs[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 = 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);
@@ -541,7 +638,7 @@ export 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;
+                isRootDataStore = attributes.isRootDataStore ?? true;
                 if (hasIsolatedChannels(attributes)) {
                     tree = tree.trees[channelsTreeName];
                     assert(tree !== undefined, 0x1fe /* "isolated channels subtree should exist in remote datastore snapshot" */);
@@ -555,23 +652,13 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
             };
         });
         this.initSnapshotValue = props.snapshotTree;
-        this.baseGCDetailsP = new 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");
     }
@@ -581,7 +668,39 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
  */
 export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
     constructor(props) {
-        super(props, props.snapshotTree !== undefined ? true : false /* existing */, props.snapshotTree ? BindState.Bound : BindState.NotBound, true /* isLocalDataStore */, props.makeLocallyVisibleFn);
+        super(props, props.snapshotTree !== undefined ? true : false /* existing */, true /* isLocalDataStore */, props.makeLocallyVisibleFn);
+        this.initialSnapshotDetailsP = new 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 getFluidDataStoreAttributes(this.storage, snapshot);
+                if (hasIsolatedChannels(attributes)) {
+                    snapshot = snapshot.trees[channelsTreeName];
+                    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();
+                    }
+                }
+            }
+            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();
@@ -603,12 +722,10 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
         assert(this.channel !== undefined, 0x14f /* "There should be a channel when generating attach message" */);
         assert(this.pkg !== undefined, 0x150 /* "pkg should be available in local data store context" */);
         const summarizeResult = this.channel.getAttachSummary();
-        if (!this.disableIsolatedChannels) {
-            // Wrap dds summaries in .channels subtree.
-            wrapSummaryInChannelsTree(summarizeResult);
-        }
+        // Wrap dds summaries in .channels subtree.
+        wrapSummaryInChannelsTree(summarizeResult);
         // Add data store's attributes to the summary.
-        const attributes = createAttributes(this.pkg, this.isInMemoryRoot(), this.disableIsolatedChannels);
+        const attributes = createAttributes(this.pkg, this.isInMemoryRoot());
         addBlobToSummary(summarizeResult, dataStoreAttributesBlobName, JSON.stringify(attributes));
         // Attach message needs the summary in ITree format. Convert the ISummaryTree into an ITree.
         const snapshot = convertSummaryTreeToITree(summarizeResult.summary);
@@ -620,46 +737,24 @@ export 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 getFluidDataStoreAttributes(this.storage, snapshot);
-            if (hasIsolatedChannels(attributes)) {
-                snapshot = snapshot.trees[channelsTreeName];
-                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();
-                }
-            }
-        }
-        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.
+        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();
     }
 }
 /**
@@ -686,24 +781,25 @@ export class LocalDetachedFluidDataStoreContext extends LocalFluidDataStoreConte
     }
     async attachRuntime(registry, dataStoreChannel) {
         assert(this.detachedRuntimeCreation, 0x154 /* "runtime creation is already attached" */);
+        this.detachedRuntimeCreation = false;
         assert(this.channelDeferred === undefined, 0x155 /* "channel deferral is already set" */);
+        this.channelDeferred = new Deferred();
         const factory = registry.IFluidDataStoreFactory;
         const entry = await this.factoryFromPackagePath(this.pkg);
         assert(entry.factory === factory, 0x156 /* "Unexpected factory for package path" */);
         assert(this.registry === undefined, 0x157 /* "datastore registry already attached" */);
         this.registry = entry.registry;
-        this.detachedRuntimeCreation = false;
-        this.channelDeferred = new 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() {
@@ -713,4 +809,4 @@ export class LocalDetachedFluidDataStoreContext extends LocalFluidDataStoreConte
         return super.getInitialSnapshotDetails();
     }
 }
-//# sourceMappingURL=dataStoreContext.js.map
+//# sourceMappingURL=dataStoreContext.mjs.map