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

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

@@ -5,55 +5,48 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSummaryForDatastores = exports.DataStores = void 0;
-const container_utils_1 = require("@fluidframework/container-utils");
 const datastore_1 = require("@fluidframework/datastore");
 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_definitions_1 = require("@fluidframework/container-definitions");
 const driver_utils_1 = require("@fluidframework/driver-utils");
-const common_utils_1 = require("@fluidframework/common-utils");
+const core_utils_1 = require("@fluidframework/core-utils");
 const uuid_1 = require("uuid");
-const garbage_collector_1 = require("@fluidframework/garbage-collector");
-const dataStoreContexts_1 = require("./dataStoreContexts");
-const dataStoreContext_1 = require("./dataStoreContext");
-const summaryFormat_1 = require("./summaryFormat");
-const dataStore_1 = require("./dataStore");
-const garbageCollection_1 = require("./garbageCollection");
+const dataStoreContexts_1 = require("./dataStoreContexts.cjs");
+const containerRuntime_1 = require("./containerRuntime.cjs");
+const dataStoreContext_1 = require("./dataStoreContext.cjs");
+const storageServiceWithAttachBlobs_1 = require("./storageServiceWithAttachBlobs.cjs");
+const dataStore_1 = require("./dataStore.cjs");
+const gc_1 = require("./gc/index.cjs");
+const summary_1 = require("./summary/index.cjs");
 /**
  * This class encapsulates data store handling. Currently it is only used by the container runtime,
  * but eventually could be hosted on any channel once we formalize the channel api boundary.
  */
 class DataStores {
-    constructor(baseSnapshot, runtime, submitAttachFn, getCreateChildSummarizerNodeFn, deleteChildSummarizerNodeFn, baseLogger, getBaseGCDetails, gcNodeUpdated, aliasMap, writeGCDataAtRoot, contexts = new dataStoreContexts_1.DataStoreContexts(baseLogger)) {
+    constructor(baseSnapshot, runtime, submitAttachFn, getCreateChildSummarizerNodeFn, deleteChildSummarizerNodeFn, baseLogger, gcNodeUpdated, isDataStoreDeleted, aliasMap, contexts = new dataStoreContexts_1.DataStoreContexts(baseLogger)) {
         this.baseSnapshot = baseSnapshot;
         this.runtime = runtime;
         this.submitAttachFn = submitAttachFn;
         this.getCreateChildSummarizerNodeFn = getCreateChildSummarizerNodeFn;
         this.deleteChildSummarizerNodeFn = deleteChildSummarizerNodeFn;
         this.gcNodeUpdated = gcNodeUpdated;
+        this.isDataStoreDeleted = isDataStoreDeleted;
         this.aliasMap = aliasMap;
-        this.writeGCDataAtRoot = writeGCDataAtRoot;
         this.contexts = contexts;
         // Stores tracked by the Domain
         this.pendingAttach = new Map();
         // 0.24 back-compat attachingBeforeSummary
         this.attachOpFiredForDataStore = new Set();
-        this.disposeOnce = new common_utils_1.Lazy(() => this.contexts.dispose());
+        this.disposeOnce = new core_utils_1.Lazy(() => this.contexts.dispose());
         // Stores the ids of new data stores between two GC runs. This is used to notify the garbage collector of new
         // root data stores that are added.
         this.dataStoresSinceLastGC = [];
+        this.pendingAliasMap = new Map();
         this.dispose = () => this.disposeOnce.value;
-        this.logger = telemetry_utils_1.ChildLogger.create(baseLogger);
+        this.mc = (0, telemetry_utils_1.createChildMonitoringContext)({ logger: baseLogger });
         this.containerRuntimeHandle = new datastore_1.FluidObjectHandle(this.runtime, "/", this.runtime.IFluidHandleContext);
-        const baseGCDetailsP = new common_utils_1.LazyPromise(async () => {
-            return getBaseGCDetails();
-        });
-        // Returns the base GC details for the data store with the given id.
-        const dataStoreBaseGCDetails = async (dataStoreId) => {
-            const baseGCDetails = await baseGCDetailsP;
-            return baseGCDetails.get(dataStoreId);
-        };
         // Extract stores stored inside the snapshot
         const fluidDataStores = new Map();
         if (baseSnapshot) {
@@ -74,13 +67,12 @@ class DataStores {
                 dataStoreContext = new dataStoreContext_1.RemoteFluidDataStoreContext({
                     id: key,
                     snapshotTree: value,
-                    getBaseGCDetails: async () => dataStoreBaseGCDetails(key),
                     runtime: this.runtime,
                     storage: this.runtime.storage,
                     scope: this.runtime.scope,
-                    createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(key, { type: runtime_definitions_1.CreateSummarizerNodeSource.FromSummary }),
-                    writeGCDataAtRoot: this.writeGCDataAtRoot,
-                    disableIsolatedChannels: this.runtime.disableIsolatedChannels,
+                    createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(key, {
+                        type: runtime_definitions_1.CreateSummarizerNodeSource.FromSummary,
+                    }),
                 });
             }
             else {
@@ -94,12 +86,12 @@ class DataStores {
                     runtime: this.runtime,
                     storage: this.runtime.storage,
                     scope: this.runtime.scope,
-                    createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(key, { type: runtime_definitions_1.CreateSummarizerNodeSource.FromSummary }),
+                    createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(key, {
+                        type: runtime_definitions_1.CreateSummarizerNodeSource.FromSummary,
+                    }),
                     makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(key),
                     snapshotTree,
                     isRootDataStore: undefined,
-                    writeGCDataAtRoot: this.writeGCDataAtRoot,
-                    disableIsolatedChannels: this.runtime.disableIsolatedChannels,
                 });
             }
             this.contexts.addBoundOrRemoted(dataStoreContext);
@@ -109,35 +101,41 @@ class DataStores {
             referencedDataStoreCount: fluidDataStores.size - unreferencedDataStoreCount,
         };
     }
-    aliases() {
+    get aliases() {
         return this.aliasMap;
     }
+    get pendingAliases() {
+        return this.pendingAliasMap;
+    }
+    async waitIfPendingAlias(maybeAlias) {
+        const pendingAliasPromise = this.pendingAliases.get(maybeAlias);
+        return pendingAliasPromise ?? "Success";
+    }
     processAttachMessage(message, local) {
-        var _a, _b;
         const attachMessage = message.contents;
         this.dataStoresSinceLastGC.push(attachMessage.id);
         // The local object has already been attached
         if (local) {
-            (0, common_utils_1.assert)(this.pendingAttach.has(attachMessage.id), 0x15e /* "Local object does not have matching attach message id" */);
-            (_a = this.contexts.get(attachMessage.id)) === null || _a === void 0 ? void 0 : _a.emit("attached");
+            (0, core_utils_1.assert)(this.pendingAttach.has(attachMessage.id), 0x15e /* "Local object does not have matching attach message id" */);
+            this.contexts.get(attachMessage.id)?.emit("attached");
             this.pendingAttach.delete(attachMessage.id);
             return;
         }
         // If a non-local operation then go and create the object, otherwise mark it as officially attached.
         if (this.alreadyProcessed(attachMessage.id)) {
             // TODO: dataStoreId may require a different tag from PackageData #7488
-            const error = new container_utils_1.DataCorruptionError(
+            const error = new telemetry_utils_1.DataCorruptionError(
             // pre-0.58 error message: duplicateDataStoreCreatedWithExistingId
-            "Duplicate DataStore created with existing id", Object.assign(Object.assign({}, (0, container_utils_1.extractSafePropertiesFromMessage)(message)), { dataStoreId: {
-                    value: attachMessage.id,
-                    tag: telemetry_utils_1.TelemetryDataTag.PackageData,
-                } }));
+            "Duplicate DataStore created with existing id", {
+                ...(0, telemetry_utils_1.extractSafePropertiesFromMessage)(message),
+                ...(0, telemetry_utils_1.tagCodeArtifacts)({ dataStoreId: attachMessage.id }),
+            });
             throw error;
         }
-        const flatBlobs = new Map();
+        const flatAttachBlobs = new Map();
         let snapshotTree;
         if (attachMessage.snapshot) {
-            snapshotTree = (0, driver_utils_1.buildSnapshotTree)(attachMessage.snapshot.entries, flatBlobs);
+            snapshotTree = (0, driver_utils_1.buildSnapshotTree)(attachMessage.snapshot.entries, flatAttachBlobs);
         }
         // Include the type of attach message which is the pkg of the store to be
         // used by RemoteFluidDataStoreContext in case it is not in the snapshot.
@@ -145,20 +143,16 @@ class DataStores {
         const remoteFluidDataStoreContext = new dataStoreContext_1.RemoteFluidDataStoreContext({
             id: attachMessage.id,
             snapshotTree,
-            // New data stores begin with empty GC details since GC hasn't run on them yet.
-            getBaseGCDetails: async () => { return {}; },
             runtime: this.runtime,
-            storage: new driver_utils_1.BlobCacheStorageService(this.runtime.storage, flatBlobs),
+            storage: new storageServiceWithAttachBlobs_1.StorageServiceWithAttachBlobs(this.runtime.storage, flatAttachBlobs),
             scope: this.runtime.scope,
             createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(attachMessage.id, {
                 type: runtime_definitions_1.CreateSummarizerNodeSource.FromAttach,
                 sequenceNumber: message.sequenceNumber,
-                snapshot: (_b = attachMessage.snapshot) !== null && _b !== void 0 ? _b : {
-                    entries: [(0, dataStoreContext_1.createAttributesBlob)(pkg, true /* isRootDataStore */, this.runtime.disableIsolatedChannels)],
+                snapshot: attachMessage.snapshot ?? {
+                    entries: [(0, dataStoreContext_1.createAttributesBlob)(pkg, true /* isRootDataStore */)],
                 },
             }),
-            writeGCDataAtRoot: this.writeGCDataAtRoot,
-            disableIsolatedChannels: this.runtime.disableIsolatedChannels,
             pkg,
         });
         this.contexts.addBoundOrRemoted(remoteFluidDataStoreContext);
@@ -166,7 +160,9 @@ class DataStores {
     processAliasMessage(message, localOpMetadata, local) {
         const aliasMessage = message.contents;
         if (!(0, dataStore_1.isDataStoreAliasMessage)(aliasMessage)) {
-            throw new container_utils_1.DataCorruptionError("malformedDataStoreAliasMessage", Object.assign({}, (0, container_utils_1.extractSafePropertiesFromMessage)(message)));
+            throw new telemetry_utils_1.DataCorruptionError("malformedDataStoreAliasMessage", {
+                ...(0, telemetry_utils_1.extractSafePropertiesFromMessage)(message),
+            });
         }
         const resolve = localOpMetadata;
         const aliasResult = this.processAliasMessageCore(aliasMessage);
@@ -179,8 +175,13 @@ class DataStores {
             return false;
         }
         const context = this.contexts.get(aliasMessage.internalId);
+        // If the data store has been deleted, log an error and ignore this message. This helps prevent document
+        // corruption in case a deleted data store accidentally submitted a signal.
+        if (this.checkAndLogIfDeleted(aliasMessage.internalId, context, "Changed", "processAliasMessageCore")) {
+            return false;
+        }
         if (context === undefined) {
-            this.logger.sendErrorEvent({
+            this.mc.logger.sendErrorEvent({
                 eventName: "AliasFluidDataStoreNotFound",
                 fluidDataStoreId: aliasMessage.internalId,
             });
@@ -202,7 +203,7 @@ class DataStores {
      */
     makeDataStoreLocallyVisible(id) {
         const localContext = this.contexts.getUnbound(id);
-        (0, common_utils_1.assert)(!!localContext, 0x15f /* "Could not find unbound context to bind" */);
+        (0, core_utils_1.assert)(!!localContext, 0x15f /* "Could not find unbound context to bind" */);
         /**
          * If the container is not detached, it is globally visible to all clients. This data store should also be
          * globally visible. Move it to attaching state and send an "attach" op for it.
@@ -218,59 +219,79 @@ class DataStores {
         this.contexts.bind(id);
     }
     createDetachedDataStoreCore(pkg, isRoot, id = (0, uuid_1.v4)()) {
-        (0, common_utils_1.assert)(!id.includes("/"), 0x30c /* Id cannot contain slashes */);
+        (0, core_utils_1.assert)(!id.includes("/"), 0x30c /* Id cannot contain slashes */);
         const context = new dataStoreContext_1.LocalDetachedFluidDataStoreContext({
             id,
             pkg,
             runtime: this.runtime,
             storage: this.runtime.storage,
             scope: this.runtime.scope,
-            createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(id, { type: runtime_definitions_1.CreateSummarizerNodeSource.Local }),
+            createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(id, {
+                type: runtime_definitions_1.CreateSummarizerNodeSource.Local,
+            }),
             makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(id),
             snapshotTree: undefined,
             isRootDataStore: isRoot,
-            writeGCDataAtRoot: this.writeGCDataAtRoot,
-            disableIsolatedChannels: this.runtime.disableIsolatedChannels,
         });
         this.contexts.addUnbound(context);
         return context;
     }
-    _createFluidDataStoreContext(pkg, id, isRoot, props) {
-        (0, common_utils_1.assert)(!id.includes("/"), 0x30d /* Id cannot contain slashes */);
+    _createFluidDataStoreContext(pkg, id, props) {
+        (0, core_utils_1.assert)(!id.includes("/"), 0x30d /* Id cannot contain slashes */);
         const context = new dataStoreContext_1.LocalFluidDataStoreContext({
             id,
             pkg,
             runtime: this.runtime,
             storage: this.runtime.storage,
             scope: this.runtime.scope,
-            createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(id, { type: runtime_definitions_1.CreateSummarizerNodeSource.Local }),
+            createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(id, {
+                type: runtime_definitions_1.CreateSummarizerNodeSource.Local,
+            }),
             makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(id),
             snapshotTree: undefined,
-            isRootDataStore: isRoot,
-            writeGCDataAtRoot: this.writeGCDataAtRoot,
-            disableIsolatedChannels: this.runtime.disableIsolatedChannels,
+            isRootDataStore: false,
             createProps: props,
         });
         this.contexts.addUnbound(context);
         return context;
     }
-    get disposed() { return this.disposeOnce.evaluated; }
-    resubmitDataStoreOp(content, localOpMetadata) {
-        const envelope = content;
+    get disposed() {
+        return this.disposeOnce.evaluated;
+    }
+    resubmitDataStoreOp(envelope, localOpMetadata) {
         const context = this.contexts.get(envelope.address);
-        (0, common_utils_1.assert)(!!context, 0x160 /* "There should be a store context for the op" */);
+        // If the data store has been deleted, log an error and throw an error. If there are local changes for a
+        // deleted data store, it can otherwise lead to inconsistent state when compared to other clients.
+        if (this.checkAndLogIfDeleted(envelope.address, context, "Changed", "resubmitDataStoreOp")) {
+            throw new telemetry_utils_1.DataCorruptionError("Context is deleted!", {
+                callSite: "resubmitDataStoreOp",
+                ...(0, telemetry_utils_1.tagCodeArtifacts)({ id: envelope.address }),
+            });
+        }
+        (0, core_utils_1.assert)(!!context, 0x160 /* "There should be a store context for the op" */);
         context.reSubmit(envelope.contents, localOpMetadata);
     }
-    rollbackDataStoreOp(content, localOpMetadata) {
-        const envelope = content;
+    rollbackDataStoreOp(envelope, localOpMetadata) {
         const context = this.contexts.get(envelope.address);
-        (0, common_utils_1.assert)(!!context, 0x2e8 /* "There should be a store context for the op" */);
+        // If the data store has been deleted, log an error and throw an error. If there are local changes for a
+        // deleted data store, it can otherwise lead to inconsistent state when compared to other clients.
+        if (this.checkAndLogIfDeleted(envelope.address, context, "Changed", "rollbackDataStoreOp")) {
+            throw new telemetry_utils_1.DataCorruptionError("Context is deleted!", {
+                callSite: "rollbackDataStoreOp",
+                ...(0, telemetry_utils_1.tagCodeArtifacts)({ id: envelope.address }),
+            });
+        }
+        (0, core_utils_1.assert)(!!context, 0x2e8 /* "There should be a store context for the op" */);
         context.rollback(envelope.contents, localOpMetadata);
     }
-    async applyStashedOp(content) {
-        const envelope = content;
+    async applyStashedOp(envelope) {
         const context = this.contexts.get(envelope.address);
-        (0, common_utils_1.assert)(!!context, 0x161 /* "There should be a store context for the op" */);
+        // If the data store has been deleted, log an error and ignore this message. This helps prevent document
+        // corruption in case the data store that stashed the op is deleted.
+        if (this.checkAndLogIfDeleted(envelope.address, context, "Changed", "applyStashedOp")) {
+            return undefined;
+        }
+        (0, core_utils_1.assert)(!!context, 0x161 /* "There should be a store context for the op" */);
         return context.applyStashedOp(envelope.contents);
     }
     async applyStashedAttachOp(message) {
@@ -280,16 +301,27 @@ class DataStores {
     }
     processFluidDataStoreOp(message, local, localMessageMetadata) {
         const envelope = message.contents;
-        const transformed = Object.assign(Object.assign({}, message), { contents: envelope.contents });
+        const transformed = { ...message, contents: envelope.contents };
         const context = this.contexts.get(envelope.address);
-        (0, common_utils_1.assert)(!!context, 0x162 /* "There should be a store context for the op" */);
+        // If the data store has been deleted, log an error and ignore this message. This helps prevent document
+        // corruption in case a deleted data store accidentally submitted an op.
+        if (this.checkAndLogIfDeleted(envelope.address, context, "Changed", "processFluidDataStoreOp")) {
+            return;
+        }
+        (0, core_utils_1.assert)(!!context, 0x162 /* "There should be a store context for the op" */);
         context.process(transformed, local, localMessageMetadata);
         // Notify that a GC node for the data store changed. This is used to detect if a deleted data store is
         // being used.
         this.gcNodeUpdated(`/${envelope.address}`, message.timestamp, context.isLoaded ? context.packagePath : undefined);
     }
-    async getDataStore(id, wait) {
-        const context = await this.contexts.getBoundOrRemoted(id, wait);
+    async getDataStore(id, requestHeaderData) {
+        const headerData = { ...containerRuntime_1.defaultRuntimeHeaderData, ...requestHeaderData };
+        if (this.checkAndLogIfDeleted(id, this.contexts.get(id), "Requested", "getDataStore", requestHeaderData)) {
+            // The requested data store has been deleted by gc. Create a 404 response exception.
+            const request = { url: id };
+            throw (0, runtime_utils_1.responseToException)((0, runtime_utils_1.createResponseError)(404, "DataStore was deleted", request), request);
+        }
+        const context = await this.contexts.getBoundOrRemoted(id, headerData.wait);
         if (context === undefined) {
             // The requested data store does not exits. Throw a 404 response exception.
             const request = { url: id };
@@ -297,44 +329,85 @@ class DataStores {
         }
         return context;
     }
-    processSignal(address, message, local) {
-        const context = this.contexts.get(address);
+    /**
+     * Returns the data store requested with the given id if available. Otherwise, returns undefined.
+     */
+    async getDataStoreIfAvailable(id, requestHeaderData) {
+        // If the data store has been deleted, log an error and return undefined.
+        if (this.checkAndLogIfDeleted(id, this.contexts.get(id), "Requested", "getDataStoreIfAvailable", requestHeaderData)) {
+            return undefined;
+        }
+        const headerData = { ...containerRuntime_1.defaultRuntimeHeaderData, ...requestHeaderData };
+        const context = await this.contexts.getBoundOrRemoted(id, headerData.wait);
+        if (context === undefined) {
+            return undefined;
+        }
+        return context;
+    }
+    /**
+     * Checks if the data store has been deleted by GC. If so, log an error.
+     * @param id - The data store's id.
+     * @param context - The data store context.
+     * @param callSite - The function name this is called from.
+     * @param requestHeaderData - The request header information to log if the data store is deleted.
+     * @returns true if the data store is deleted. Otherwise, returns false.
+     */
+    checkAndLogIfDeleted(id, context, deletedLogSuffix, callSite, requestHeaderData) {
+        const dataStoreNodePath = `/${id}`;
+        if (!this.isDataStoreDeleted(dataStoreNodePath)) {
+            return false;
+        }
+        this.mc.logger.sendErrorEvent({
+            eventName: `GC_Deleted_DataStore_${deletedLogSuffix}`,
+            ...(0, telemetry_utils_1.tagCodeArtifacts)({ id }),
+            callSite,
+            headers: JSON.stringify(requestHeaderData),
+            exists: context !== undefined,
+        });
+        return true;
+    }
+    processSignal(fluidDataStoreId, message, local) {
+        const context = this.contexts.get(fluidDataStoreId);
+        // If the data store has been deleted, log an error and ignore this message. This helps prevent document
+        // corruption in case a deleted data store accidentally submitted a signal.
+        if (this.checkAndLogIfDeleted(fluidDataStoreId, context, "Changed", "processSignal")) {
+            return;
+        }
         if (!context) {
             // Attach message may not have been processed yet
-            (0, common_utils_1.assert)(!local, 0x163 /* "Missing datastore for local signal" */);
-            this.logger.sendTelemetryEvent({
+            (0, core_utils_1.assert)(!local, 0x163 /* "Missing datastore for local signal" */);
+            this.mc.logger.sendTelemetryEvent({
                 eventName: "SignalFluidDataStoreNotFound",
-                fluidDataStoreId: {
-                    value: address,
-                    tag: telemetry_utils_1.TelemetryDataTag.PackageData,
-                },
+                ...(0, telemetry_utils_1.tagCodeArtifacts)({
+                    fluidDataStoreId,
+                }),
             });
             return;
         }
         context.processSignal(message, local);
     }
     setConnectionState(connected, clientId) {
-        for (const [fluidDataStore, context] of this.contexts) {
+        for (const [fluidDataStoreId, context] of this.contexts) {
             try {
                 context.setConnectionState(connected, clientId);
             }
             catch (error) {
-                this.logger.sendErrorEvent({
+                this.mc.logger.sendErrorEvent({
                     eventName: "SetConnectionStateError",
                     clientId,
-                    fluidDataStore,
+                    ...(0, telemetry_utils_1.tagCodeArtifacts)({
+                        fluidDataStoreId,
+                    }),
+                    details: JSON.stringify({
+                        runtimeConnected: this.runtime.connected,
+                        connected,
+                    }),
                 }, error);
             }
         }
     }
     setAttachState(attachState) {
-        let eventName;
-        if (attachState === container_definitions_1.AttachState.Attaching) {
-            eventName = "attaching";
-        }
-        else {
-            eventName = "attached";
-        }
+        const eventName = attachState === container_definitions_1.AttachState.Attaching ? "attaching" : "attached";
         for (const [, context] of this.contexts) {
             // Fire only for bounded stores.
             if (!this.contexts.isNotBound(context.id)) {
@@ -350,10 +423,17 @@ class DataStores {
         // Iterate over each store and ask it to snapshot
         await Promise.all(Array.from(this.contexts)
             .filter(([_, context]) => {
-            // Summarizer works only with clients with no local changes!
-            (0, common_utils_1.assert)(context.attachState !== container_definitions_1.AttachState.Attaching, 0x165 /* "Summarizer cannot work if client has local changes" */);
+            // Summarizer works only with clients with no local changes. A data store in attaching
+            // state indicates an op was sent to attach a local data store, and the the attach op
+            // had not yet round tripped back to the client.
+            if (context.attachState === container_definitions_1.AttachState.Attaching) {
+                // Formerly assert 0x588
+                const error = telemetry_utils_1.DataProcessingError.create("Local data store detected in attaching state during summarize", "summarize");
+                throw error;
+            }
             return context.attachState === container_definitions_1.AttachState.Attached;
-        }).map(async ([contextId, context]) => {
+        })
+            .map(async ([contextId, context]) => {
             const contextSummary = await context.summarize(fullTree, trackState, telemetryContext);
             summaryBuilder.addWithStats(contextId, contextSummary);
         }));
@@ -373,9 +453,9 @@ class DataStores {
             // Take summary of bounded data stores only, make sure we haven't summarized them already
             // and no attach op has been fired for that data store because for loader versions <= 0.24
             // we set attach state as "attaching" before taking createNew summary.
-            !(this.contexts.isNotBound(key)
-                || builderTree[key]
-                || this.attachOpFiredForDataStore.has(key)))
+            !(this.contexts.isNotBound(key) ||
+                builderTree[key] ||
+                this.attachOpFiredForDataStore.has(key)))
                 .map(([key, value]) => {
                 let dataStoreSummary;
                 if (value.isLoaded) {
@@ -385,7 +465,7 @@ class DataStores {
                 else {
                     // If this data store is not yet loaded, then there should be no changes in the snapshot from
                     // which it was created as it is detached container. So just use the previous snapshot.
-                    (0, common_utils_1.assert)(!!this.baseSnapshot, 0x166 /* "BaseSnapshot should be there as detached container loaded from snapshot" */);
+                    (0, core_utils_1.assert)(!!this.baseSnapshot, 0x166 /* "BaseSnapshot should be there as detached container loaded from snapshot" */);
                     dataStoreSummary = (0, runtime_utils_1.convertSnapshotTreeToSummaryTree)(this.baseSnapshot.trees[key]);
                 }
                 builder.addWithStats(key, dataStoreSummary);
@@ -401,7 +481,7 @@ class DataStores {
     async updateStateBeforeGC() {
         for (const id of this.dataStoresSinceLastGC) {
             const context = this.contexts.get(id);
-            (0, common_utils_1.assert)(context !== undefined, 0x2b6 /* Missing data store context */);
+            (0, core_utils_1.assert)(context !== undefined, 0x2b6 /* Missing data store context */);
             if (await context.isRoot()) {
                 // A root data store is basically a reference from the container runtime to the data store.
                 const handle = new datastore_1.FluidObjectHandle(context, id, this.runtime.IFluidHandleContext);
@@ -412,22 +492,33 @@ class DataStores {
     }
     /**
      * Generates data used for garbage collection. It does the following:
+     *
      * 1. Calls into each child data store context to get its GC data.
+     *
      * 2. Prefixes the child context's id to the GC nodes in the child's GC data. This makes sure that the node can be
-     *    identified as belonging to the child.
+     * identified as belonging to the child.
+     *
      * 3. Adds a GC node for this channel to the nodes received from the children. All these nodes together represent
-     *    the GC data of this channel.
+     * the GC data of this channel.
+     *
      * @param fullGC - true to bypass optimizations and force full generation of GC data.
      */
     async getGCData(fullGC = false) {
-        const builder = new garbage_collector_1.GCDataBuilder();
+        const builder = new runtime_utils_1.GCDataBuilder();
         // Iterate over each store and get their GC data.
         await Promise.all(Array.from(this.contexts)
             .filter(([_, context]) => {
-            // Get GC data only for attached contexts. Detached contexts are not connected in the GC reference
-            // graph so any references they might have won't be connected as well.
+            // Summarizer client and hence GC works only with clients with no local changes. A data store in
+            // attaching state indicates an op was sent to attach a local data store, and the the attach op
+            // had not yet round tripped back to the client.
+            // Formerly assert 0x589
+            if (context.attachState === container_definitions_1.AttachState.Attaching) {
+                const error = telemetry_utils_1.DataProcessingError.create("Local data store detected in attaching state while running GC", "getGCData");
+                throw error;
+            }
             return context.attachState === container_definitions_1.AttachState.Attached;
-        }).map(async ([contextId, context]) => {
+        })
+            .map(async ([contextId, context]) => {
             const contextGCData = await context.getGCData(fullGC);
             // Prefix the child's id to the ids of its GC nodes so they can be identified as belonging to the child.
             // This also gradually builds the id of each node to be a path from the root.
@@ -440,28 +531,24 @@ class DataStores {
     /**
      * After GC has run, called to notify this Container's data stores of routes that are used in it.
      * @param usedRoutes - The routes that are used in all data stores in this Container.
-     * @param gcTimestamp - The time when GC was run that generated these used routes. If any node node becomes
-     * unreferenced as part of this GC run, this should be used to update the time when it happens.
      */
-    updateUsedRoutes(usedRoutes, gcTimestamp) {
-        var _a;
+    updateUsedRoutes(usedRoutes) {
         // Get a map of data store ids to routes used in it.
-        const usedDataStoreRoutes = (0, garbage_collector_1.unpackChildNodesUsedRoutes)(usedRoutes);
+        const usedDataStoreRoutes = (0, runtime_utils_1.unpackChildNodesUsedRoutes)(usedRoutes);
         // Verify that the used routes are correct.
         for (const [id] of usedDataStoreRoutes) {
-            (0, common_utils_1.assert)(this.contexts.has(id), 0x167 /* "Used route does not belong to any known data store" */);
+            (0, core_utils_1.assert)(this.contexts.has(id), 0x167 /* "Used route does not belong to any known data store" */);
         }
         // Update the used routes in each data store. Used routes is empty for unused data stores.
         for (const [contextId, context] of this.contexts) {
-            context.updateUsedRoutes((_a = usedDataStoreRoutes.get(contextId)) !== null && _a !== void 0 ? _a : [], gcTimestamp);
+            context.updateUsedRoutes(usedDataStoreRoutes.get(contextId) ?? []);
         }
     }
     /**
-     * When running GC in test mode, this is called to delete objects whose routes are unused. This enables testing
-     * scenarios with accessing deleted content.
+     * This is called to update objects whose routes are unused. The unused objects are deleted.
      * @param unusedRoutes - The routes that are unused in all data stores in this Container.
      */
-    deleteUnusedRoutes(unusedRoutes) {
+    updateUnusedRoutes(unusedRoutes) {
         for (const route of unusedRoutes) {
             const pathParts = route.split("/");
             // Delete data store only if its route (/datastoreId) is in unusedRoutes. We don't want to delete a data
@@ -470,13 +557,73 @@ class DataStores {
                 continue;
             }
             const dataStoreId = pathParts[1];
-            (0, common_utils_1.assert)(this.contexts.has(dataStoreId), 0x2d7 /* No data store with specified id */);
+            (0, core_utils_1.assert)(this.contexts.has(dataStoreId), 0x2d7 /* No data store with specified id */);
             // Delete the contexts of unused data stores.
             this.contexts.delete(dataStoreId);
             // Delete the summarizer node of the unused data stores.
             this.deleteChildSummarizerNodeFn(dataStoreId);
         }
     }
+    /**
+     * Delete data stores and its objects that are sweep ready.
+     * @param sweepReadyDataStoreRoutes - The routes of data stores and its objects that are sweep ready and should
+     * be deleted.
+     * @returns The routes of data stores and its objects that were deleted.
+     */
+    deleteSweepReadyNodes(sweepReadyDataStoreRoutes) {
+        // If sweep for data stores is not enabled, return empty list indicating nothing is deleted.
+        if (this.mc.config.getBoolean(gc_1.disableDatastoreSweepKey) === true) {
+            return [];
+        }
+        for (const route of sweepReadyDataStoreRoutes) {
+            const pathParts = route.split("/");
+            const dataStoreId = pathParts[1];
+            // Ignore sub-data store routes because a data store and its sub-routes are deleted together, so, we only
+            // need to delete the data store.
+            if (pathParts.length > 2) {
+                continue;
+            }
+            const dataStoreContext = this.contexts.get(dataStoreId);
+            if (dataStoreContext === undefined) {
+                this.mc.logger.sendErrorEvent({
+                    eventName: "DeletedDataStoreNotFound",
+                    ...(0, telemetry_utils_1.tagCodeArtifacts)({ id: dataStoreId }),
+                    details: {
+                        alreadyDeleted: this.isDataStoreDeleted(dataStoreId),
+                    },
+                });
+                continue;
+            }
+            dataStoreContext.delete();
+            // Delete the contexts of sweep ready data stores.
+            this.contexts.delete(dataStoreId);
+            // Delete the summarizer node of the sweep ready data stores.
+            this.deleteChildSummarizerNodeFn(dataStoreId);
+        }
+        return Array.from(sweepReadyDataStoreRoutes);
+    }
+    /**
+     * This is called to update objects whose routes are tombstones. Tombstoned datastore contexts enable testing
+     * scenarios with accessing deleted content without actually deleting content from summaries.
+     * @param tombstonedRoutes - The routes that are tombstones in all data stores in this Container.
+     */
+    updateTombstonedRoutes(tombstonedRoutes) {
+        const tombstonedDataStoresSet = new Set();
+        for (const route of tombstonedRoutes) {
+            const pathParts = route.split("/");
+            // Tombstone data store only if its route (/datastoreId) is directly in tombstoneRoutes.
+            if (pathParts.length > 2) {
+                continue;
+            }
+            const dataStoreId = pathParts[1];
+            (0, core_utils_1.assert)(this.contexts.has(dataStoreId), 0x510 /* No data store with specified id */);
+            tombstonedDataStoresSet.add(dataStoreId);
+        }
+        // Update the used routes in each data store. Used routes is empty for unused data stores.
+        for (const [contextId, context] of this.contexts) {
+            context.setTombstone(tombstonedDataStoresSet.has(contextId));
+        }
+    }
     /**
      * Returns the outbound routes of this channel. Only root data stores are considered referenced and their paths are
      * part of outbound routes.
@@ -495,11 +642,10 @@ class DataStores {
      * Called by GC to retrieve the package path of a data store node with the given path.
      */
     async getDataStorePackagePath(nodePath) {
-        var _a;
         // If the node belongs to a data store, return its package path. For DDSes, we return the package path of the
         // data store that contains it.
         const context = this.contexts.get(nodePath.split("/")[1]);
-        return (_a = (await (context === null || context === void 0 ? void 0 : context.getInitialSnapshotDetails()))) === null || _a === void 0 ? void 0 : _a.pkg;
+        return (await context?.getInitialSnapshotDetails())?.pkg;
     }
     /**
      * Called by GC to determine if a node is for a data store or for an object within a data store (for e.g. DDS).
@@ -513,9 +659,9 @@ class DataStores {
         // Data stores paths are of the format "/dataStoreId".
         // Sub data store paths are of the format "/dataStoreId/subPath/...".
         if (pathParts.length === 2) {
-            return garbageCollection_1.GCNodeType.DataStore;
+            return gc_1.GCNodeType.DataStore;
         }
-        return garbageCollection_1.GCNodeType.SubDataStore;
+        return gc_1.GCNodeType.SubDataStore;
     }
 }
 exports.DataStores = DataStores;
@@ -523,21 +669,24 @@ function getSummaryForDatastores(snapshot, metadata) {
     if (!snapshot) {
         return undefined;
     }
-    if ((0, summaryFormat_1.rootHasIsolatedChannels)(metadata)) {
+    if ((0, summary_1.rootHasIsolatedChannels)(metadata)) {
         const datastoresSnapshot = snapshot.trees[runtime_definitions_1.channelsTreeName];
-        (0, common_utils_1.assert)(!!datastoresSnapshot, 0x168 /* Expected tree in snapshot not found */);
+        (0, core_utils_1.assert)(!!datastoresSnapshot, 0x168 /* Expected tree in snapshot not found */);
         return datastoresSnapshot;
     }
     else {
         // back-compat: strip out all non-datastore paths before giving to DataStores object.
         const datastoresTrees = {};
         for (const [key, value] of Object.entries(snapshot.trees)) {
-            if (!summaryFormat_1.nonDataStorePaths.includes(key)) {
+            if (!summary_1.nonDataStorePaths.includes(key)) {
                 datastoresTrees[key] = value;
             }
         }
-        return Object.assign(Object.assign({}, snapshot), { trees: datastoresTrees });
+        return {
+            ...snapshot,
+            trees: datastoresTrees,
+        };
     }
 }
 exports.getSummaryForDatastores = getSummaryForDatastores;
-//# sourceMappingURL=dataStores.js.map
+//# sourceMappingURL=dataStores.cjs.map