@fluidframework/container-runtime 2.0.0-internal.3.0.1 → 2.0.0-internal.3.1.0

package/lib/garbageCollection.js

@@ -14,7 +14,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { assert, LazyPromise, Timer } from "@fluidframework/common-utils";
-import { ClientSessionExpiredError, DataProcessingError, UsageError } from "@fluidframework/container-utils";
+import { ClientSessionExpiredError, DataProcessingError, UsageError, } from "@fluidframework/container-utils";
 import { cloneGCData, concatGarbageCollectionData, getGCDataFromSnapshot, runGarbageCollection, trimLeadingSlashes, } from "@fluidframework/garbage-collector";
 import { SummaryType } from "@fluidframework/protocol-definitions";
 import { gcTreeKey, gcBlobPrefix, gcTombstoneBlobKey, gcDeletedBlobKey, } from "@fluidframework/runtime-definitions";
@@ -22,8 +22,8 @@ import { mergeStats, packagePathToTelemetryProperty, SummaryTreeBuilder, } from
 import { ChildLogger, generateStack, loggerToMonitoringContext, PerformanceEvent, TelemetryDataTag, } from "@fluidframework/telemetry-utils";
 import { RuntimeHeaders } from "./containerRuntime";
 import { getSummaryForDatastores } from "./dataStores";
-import { currentGCVersion, defaultInactiveTimeoutMs, defaultSessionExpiryDurationMs, disableSweepLogKey, disableTombstoneKey, gcVersionUpgradeToV2Key, gcTestModeKey, oneDayMs, runGCKey, runSessionExpiryKey, runSweepKey, stableGCVersion, trackGCStateKey } from "./garbageCollectionConstants";
-import { sendGCTombstoneEvent } from "./garbageCollectionTombstoneUtils";
+import { currentGCVersion, defaultInactiveTimeoutMs, defaultSessionExpiryDurationMs, disableSweepLogKey, disableTombstoneKey, gcVersionUpgradeToV2Key, gcTestModeKey, oneDayMs, runGCKey, runSessionExpiryKey, runSweepKey, stableGCVersion, trackGCStateKey, gcTombstoneGenerationOptionName, } from "./garbageCollectionConstants";
+import { sendGCUnexpectedUsageEvent } from "./garbageCollectionHelpers";
 import { SweepReadyUsageDetectionHandler } from "./gcSweepReadyUsageDetection";
 import { getGCVersion, metadataBlobName, dataStoreAttributesBlobName, } from "./summaryFormat";
 /** The types of GC nodes in the GC reference graph. */
@@ -124,15 +124,15 @@ export class UnreferencedStateTracker {
  * Graph - all nodes with their respective routes
  *
  * ```
- *             GC Graph
+ *			 GC Graph
  *
- *               Node
- *        NodeId = "datastore1"
- *           /             \\
- *    OutboundRoute   OutboundRoute
- *         /                 \\
- *       Node               Node
- *  NodeId = "dds1"     NodeId = "dds2"
+ *			   Node
+ *		NodeId = "datastore1"
+ *		   /			 \\
+ *	OutboundRoute   OutboundRoute
+ *		 /				 \\
+ *	   Node			   Node
+ *  NodeId = "dds1"	 NodeId = "dds2"
  * ```
  */
 export class GarbageCollector {
@@ -164,10 +164,14 @@ export class GarbageCollector {
         const baseSnapshot = createParams.baseSnapshot;
         const metadata = createParams.metadata;
         const readAndParseBlob = createParams.readAndParseBlob;
-        this.mc = loggerToMonitoringContext(ChildLogger.create(createParams.baseLogger, "GarbageCollector", { all: { completedGCRuns: () => this.completedRuns } }));
+        this.mc = loggerToMonitoringContext(ChildLogger.create(createParams.baseLogger, "GarbageCollector", {
+            all: { completedGCRuns: () => this.completedRuns },
+        }));
         // If version upgrade is not enabled, fall back to the stable GC version.
         this.currentGCVersion =
-            this.mc.config.getBoolean(gcVersionUpgradeToV2Key) === true ? currentGCVersion : stableGCVersion;
+            this.mc.config.getBoolean(gcVersionUpgradeToV2Key) === true
+                ? currentGCVersion
+                : stableGCVersion;
         this.sweepReadyUsageHandler = new SweepReadyUsageDetectionHandler(createParams.getContainerDiagnosticId(), this.mc, this.runtime.closeFn);
         let prevSummaryGCVersion;
         /**
@@ -181,8 +185,8 @@ export class GarbageCollector {
         function computeSweepTimeout(sessionExpiryTimeoutMs) {
             const maxSnapshotCacheExpiryMs = 5 * oneDayMs;
             const bufferMs = oneDayMs;
-            return sessionExpiryTimeoutMs &&
-                (sessionExpiryTimeoutMs + maxSnapshotCacheExpiryMs + bufferMs);
+            return (sessionExpiryTimeoutMs &&
+                sessionExpiryTimeoutMs + maxSnapshotCacheExpiryMs + bufferMs);
         }
         /**
          * The following GC state is enabled during container creation and cannot be changed throughout its lifetime:
@@ -200,6 +204,7 @@ export class GarbageCollector {
             this.sessionExpiryTimeoutMs = metadata === null || metadata === void 0 ? void 0 : metadata.sessionExpiryTimeoutMs;
             this.sweepTimeoutMs =
                 (_b = metadata === null || metadata === void 0 ? void 0 : metadata.sweepTimeoutMs) !== null && _b !== void 0 ? _b : computeSweepTimeout(this.sessionExpiryTimeoutMs); // Backfill old documents that didn't persist this
+            this.persistedGcFeatureMatrix = metadata === null || metadata === void 0 ? void 0 : metadata.gcFeatureMatrix;
         }
         else {
             // Sweep should not be enabled without enabling GC mark phase. We could silently disable sweep in this
@@ -216,17 +221,25 @@ export class GarbageCollector {
             this.sweepEnabled = this.gcOptions.sweepAllowed === true;
             // Set the Session Expiry only if the flag is enabled and GC is enabled.
             if (this.mc.config.getBoolean(runSessionExpiryKey) && this.gcEnabled) {
-                this.sessionExpiryTimeoutMs = (_c = this.gcOptions.sessionExpiryTimeoutMs) !== null && _c !== void 0 ? _c : defaultSessionExpiryDurationMs;
+                this.sessionExpiryTimeoutMs =
+                    (_c = this.gcOptions.sessionExpiryTimeoutMs) !== null && _c !== void 0 ? _c : defaultSessionExpiryDurationMs;
             }
             this.sweepTimeoutMs =
                 testOverrideSweepTimeoutMs !== null && testOverrideSweepTimeoutMs !== void 0 ? testOverrideSweepTimeoutMs : computeSweepTimeout(this.sessionExpiryTimeoutMs);
+            if (this.gcOptions[gcTombstoneGenerationOptionName] !== undefined) {
+                this.persistedGcFeatureMatrix = {
+                    tombstoneGeneration: this.gcOptions[gcTombstoneGenerationOptionName],
+                };
+            }
         }
         // If session expiry is enabled, we need to close the container when the session expiry timeout expires.
         if (this.sessionExpiryTimeoutMs !== undefined) {
             // If Test Override config is set, override Session Expiry timeout.
             const overrideSessionExpiryTimeoutMs = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.SessionExpiryMs");
             const timeoutMs = overrideSessionExpiryTimeoutMs !== null && overrideSessionExpiryTimeoutMs !== void 0 ? overrideSessionExpiryTimeoutMs : this.sessionExpiryTimeoutMs;
-            this.sessionExpiryTimer = new Timer(timeoutMs, () => { this.runtime.closeFn(new ClientSessionExpiredError(`Client session expired.`, timeoutMs)); });
+            this.sessionExpiryTimer = new Timer(timeoutMs, () => {
+                this.runtime.closeFn(new ClientSessionExpiredError(`Client session expired.`, timeoutMs));
+            });
             this.sessionExpiryTimer.start();
         }
         // For existing document, the latest summary is the one that we loaded from. So, use its GC version as the
@@ -241,11 +254,12 @@ export class GarbageCollector {
          *
          * These conditions can be overridden via runGCKey feature flag.
          */
-        this.shouldRunGC = (_d = this.mc.config.getBoolean(runGCKey)) !== null && _d !== void 0 ? _d : (
-        // GC must be enabled for the document.
-        this.gcEnabled
-            // GC must not be disabled via GC options.
-            && !this.gcOptions.disableGC);
+        this.shouldRunGC =
+            (_d = this.mc.config.getBoolean(runGCKey)) !== null && _d !== void 0 ? _d : 
+            // GC must be enabled for the document.
+            (this.gcEnabled &&
+                // GC must not be disabled via GC options.
+                !this.gcOptions.disableGC);
         /**
          * Whether sweep should run or not. The following conditions have to be met to run sweep:
          *
@@ -257,21 +271,24 @@ export class GarbageCollector {
          * feature flag.
          */
         this.shouldRunSweep =
-            this.shouldRunGC
-                && this.sweepTimeoutMs !== undefined
-                && ((_e = this.mc.config.getBoolean(runSweepKey)) !== null && _e !== void 0 ? _e : this.sweepEnabled);
+            this.shouldRunGC &&
+                this.sweepTimeoutMs !== undefined &&
+                ((_e = this.mc.config.getBoolean(runSweepKey)) !== null && _e !== void 0 ? _e : this.sweepEnabled);
         this.trackGCState = this.mc.config.getBoolean(trackGCStateKey) === true;
         // Override inactive timeout if test config or gc options to override it is set.
-        this.inactiveTimeoutMs = (_g = (_f = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs")) !== null && _f !== void 0 ? _f : this.gcOptions.inactiveTimeoutMs) !== null && _g !== void 0 ? _g : defaultInactiveTimeoutMs;
+        this.inactiveTimeoutMs =
+            (_g = (_f = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs")) !== null && _f !== void 0 ? _f : this.gcOptions.inactiveTimeoutMs) !== null && _g !== void 0 ? _g : defaultInactiveTimeoutMs;
         // Inactive timeout must be greater than sweep timeout since a node goes from active -> inactive -> sweep ready.
         if (this.sweepTimeoutMs !== undefined && this.inactiveTimeoutMs > this.sweepTimeoutMs) {
             throw new UsageError("inactive timeout should not be greater than the sweep timeout");
         }
         // Whether we are running in test mode. In this mode, unreferenced nodes are immediately deleted.
-        this.testMode = (_h = this.mc.config.getBoolean(gcTestModeKey)) !== null && _h !== void 0 ? _h : this.gcOptions.runGCInTestMode === true;
+        this.testMode =
+            (_h = this.mc.config.getBoolean(gcTestModeKey)) !== null && _h !== void 0 ? _h : this.gcOptions.runGCInTestMode === true;
         // Whether we are running in tombstone mode. This is enabled by default if sweep won't run. It can be disabled
         // via feature flags.
-        this.tombstoneMode = !this.shouldRunSweep && this.mc.config.getBoolean(disableTombstoneKey) !== true;
+        this.tombstoneMode =
+            !this.shouldRunSweep && this.mc.config.getBoolean(disableTombstoneKey) !== true;
         // If GC ran in the container that generated the base snapshot, it will have a GC tree.
         this.wasGCRunInLatestSummary = (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[gcTreeKey]) !== undefined;
         // Get the GC data from the base snapshot. Use LazyPromise because we only want to do this once since it
@@ -290,7 +307,9 @@ export class GarbageCollector {
                 // back-compat - Older documents will have the GC blobs in each data store's summary tree. Get them and
                 // consolidate into IGarbageCollectionState format.
                 // Add a node for the root node that is not present in older snapshot format.
-                const gcState = { gcNodes: { "/": { outboundRoutes: [] } } };
+                const gcState = {
+                    gcNodes: { "/": { outboundRoutes: [] } },
+                };
                 const dataStoreSnapshotTree = getSummaryForDatastores(baseSnapshot, metadata);
                 assert(dataStoreSnapshotTree !== undefined, 0x2a8 /* "Expected data store snapshot tree in base snapshot" */);
                 for (const [dsId, dsSnapshotTree] of Object.entries(dataStoreSnapshotTree.trees)) {
@@ -314,10 +333,13 @@ export class GarbageCollector {
                         // Prefix the data store id to the GC node ids to make them relative to the root from being
                         // relative to the data store. Similar to how its done in DataStore::getGCData.
                         const rootId = id === "/" ? dsRootId : `${dsRootId}${id}`;
-                        gcState.gcNodes[rootId] = { outboundRoutes: Array.from(outboundRoutes) };
+                        gcState.gcNodes[rootId] = {
+                            outboundRoutes: Array.from(outboundRoutes),
+                        };
                     }
                     assert(gcState.gcNodes[dsRootId] !== undefined, 0x2a9 /* GC nodes for data store not in GC blob */);
-                    gcState.gcNodes[dsRootId].unreferencedTimestampMs = gcSummaryDetails.unrefTimestamp;
+                    gcState.gcNodes[dsRootId].unreferencedTimestampMs =
+                        gcSummaryDetails.unrefTimestamp;
                 }
                 // If there is only one node (root node just added above), either GC is disabled or we are loading from
                 // the first summary generated by detached container. In both cases, GC was not run - return undefined.
@@ -411,8 +433,8 @@ export class GarbageCollector {
      * 4.2. This client's latest summary was updated from a snapshot that has a different GC version.
      */
     get summaryStateNeedsReset() {
-        return this.gcStateNeedsReset ||
-            (this.shouldRunGC && this.latestSummaryGCVersion !== this.currentGCVersion);
+        return (this.gcStateNeedsReset ||
+            (this.shouldRunGC && this.latestSummaryGCVersion !== this.currentGCVersion));
     }
     /**
      * Tells whether the GC state needs to be reset. This can happen under 3 conditions:
@@ -427,7 +449,7 @@ export class GarbageCollector {
      *
      * Note that the state will be reset only once for the first summary generated after this returns true. After that,
      * this will return false.
-    */
+     */
     get gcStateNeedsReset() {
         return this.wasGCRunInLatestSummary !== this.shouldRunGC;
     }
@@ -458,6 +480,7 @@ export class GarbageCollector {
         // If running in tombstone mode, initialize the tombstone state from the snapshot. Also, notify the runtime of
         // tombstone routes.
         if (this.tombstoneMode && baseSnapshotData.tombstones !== undefined) {
+            // Create a copy since we are writing from a source we don't control
             this.tombstones = Array.from(baseSnapshotData.tombstones);
             this.runtime.updateTombstonedRoutes(this.tombstones);
         }
@@ -485,7 +508,6 @@ export class GarbageCollector {
         for (const [, nodeStateTracker] of this.unreferencedNodesState) {
             nodeStateTracker.stopTracking();
         }
-        ;
         this.unreferencedNodesState.clear();
         // If running sweep, the tombstone state represents the list of nodes that have been deleted during sweep.
         // If running in tombstone mode, the tombstone state represents the list of nodes that have been marked as
@@ -493,7 +515,9 @@ export class GarbageCollector {
         // If this call is because we are refreshing from a snapshot due to an ack, it is likely that the GC state
         // in the snapshot is newer than this client's. And so, the deleted / tombstone nodes need to be updated.
         if (this.shouldRunSweep) {
-            const snapshotDeletedNodes = (snapshotData === null || snapshotData === void 0 ? void 0 : snapshotData.tombstones) ? new Set(snapshotData.tombstones) : undefined;
+            const snapshotDeletedNodes = (snapshotData === null || snapshotData === void 0 ? void 0 : snapshotData.deletedNodes)
+                ? new Set(snapshotData.deletedNodes)
+                : undefined;
             // If the snapshot contains deleted nodes that are not yet deleted by this client, ask the runtime to
             // delete them.
             if (snapshotDeletedNodes !== undefined) {
@@ -571,7 +595,9 @@ export class GarbageCollector {
         var _a;
         const fullGC = (_a = options.fullGC) !== null && _a !== void 0 ? _a : (this.gcOptions.runFullGC === true || this.summaryStateNeedsReset);
         const logger = options.logger
-            ? ChildLogger.create(options.logger, undefined, { all: { completedGCRuns: () => this.completedRuns } })
+            ? ChildLogger.create(options.logger, undefined, {
+                all: { completedGCRuns: () => this.completedRuns },
+            })
             : this.mc.logger;
         /**
          * If there is no current reference timestamp, skip running GC. We need the current timestamp to track
@@ -611,26 +637,29 @@ export class GarbageCollector {
         // Generate statistics from the current run. This is done before updating the current state because it
         // generates some of its data based on previous state of the system.
         const gcStats = this.generateStats(gcResult);
-        // Update the state since the last GC run. There can be nodes that were referenced between the last and
-        // the current run. We need to identify than and update their unreferenced state if needed.
-        this.updateStateSinceLastRun(gcData, logger);
-        // Update the current state and update the runtime of all routes or ids that used as per the GC run.
-        this.updateCurrentState(gcData, gcResult, currentReferenceTimestampMs);
+        // Update the current mark state and update the runtime of all used routes or ids that used as per the GC run.
+        const sweepReadyNodes = this.updateMarkPhase(gcData, gcResult, currentReferenceTimestampMs, logger);
         this.runtime.updateUsedRoutes(gcResult.referencedNodeIds);
         // Log events for objects that are ready to be deleted by sweep. When we have sweep enabled, we will
         // delete these objects here instead.
         this.logSweepEvents(logger, currentReferenceTimestampMs);
-        // If we are running in GC test mode, delete objects for unused routes. This enables testing scenarios
-        // involving access to deleted data.
-        if (this.testMode) {
+        let updatedGCData = gcData;
+        if (this.shouldRunSweep) {
+            updatedGCData = this.runSweepPhase(sweepReadyNodes, gcData);
+        }
+        else if (this.testMode) {
+            // If we are running in GC test mode, delete objects for unused routes. This enables testing scenarios
+            // involving access to deleted data.
             this.runtime.updateUnusedRoutes(gcResult.deletedNodeIds);
         }
         else if (this.tombstoneMode) {
+            this.tombstones = sweepReadyNodes;
             // If we are running in GC tombstone mode, update tombstoned routes. This enables testing scenarios
             // involving access to "deleted" data without actually deleting the data from summaries.
             // Note: we will not tombstone in test mode.
             this.runtime.updateTombstonedRoutes(this.tombstones);
         }
+        this.gcDataFromLastRun = cloneGCData(updatedGCData);
         // Log pending unreferenced events such as a node being used after inactive. This is done after GC runs and
         // updates its state so that we don't send false positives based on intermediate state. For example, we may get
         // reference to an unreferenced node from another unreferenced node which means the node wasn't revived.
@@ -662,7 +691,9 @@ export class GarbageCollector {
             : undefined;
         // If running in tombstone mode, serialize and write tombstones, if any.
         const serializedTombstones = this.tombstoneMode
-            ? (this.tombstones.length > 0 ? JSON.stringify(this.tombstones.sort()) : undefined)
+            ? this.tombstones.length > 0
+                ? JSON.stringify(this.tombstones.sort())
+                : undefined
             : undefined;
         /**
          * Incremental summary of GC data - If none of GC state, deleted nodes or tombstones changed since last summary,
@@ -671,11 +702,15 @@ export class GarbageCollector {
          * for each of these that did not change, write a summary handle.
          */
         if (this.trackGCState) {
-            this.pendingSummaryData = { serializedGCState, serializedTombstones, serializedDeletedNodes };
+            this.pendingSummaryData = {
+                serializedGCState,
+                serializedTombstones,
+                serializedDeletedNodes,
+            };
             if (trackState && !fullTree && this.latestSummaryData !== undefined) {
                 // If nothing changed since last summary, send a summary handle for the entire GC data.
-                if (this.latestSummaryData.serializedGCState === serializedGCState
-                    && this.latestSummaryData.serializedTombstones === serializedTombstones) {
+                if (this.latestSummaryData.serializedGCState === serializedGCState &&
+                    this.latestSummaryData.serializedTombstones === serializedTombstones) {
                     const stats = mergeStats();
                     stats.handleNodeCount++;
                     return {
@@ -718,7 +753,8 @@ export class GarbageCollector {
         // If tombstones exist, write a summary handle if it hasn't changed. If it has changed, write a
         // summary blob.
         if (serializedTombstones !== undefined) {
-            if (((_b = this.latestSummaryData) === null || _b === void 0 ? void 0 : _b.serializedTombstones) === serializedTombstones && trackState) {
+            if (((_b = this.latestSummaryData) === null || _b === void 0 ? void 0 : _b.serializedTombstones) === serializedTombstones &&
+                trackState) {
                 builder.addHandle(gcTombstoneBlobKey, SummaryType.Blob, `/${gcTreeKey}/${gcTombstoneBlobKey}`);
             }
             else {
@@ -730,7 +766,8 @@ export class GarbageCollector {
             return builder.getSummaryTree();
         }
         // If the deleted nodes hasn't changed, write a summary handle, else write a summary blob for it.
-        if (((_c = this.latestSummaryData) === null || _c === void 0 ? void 0 : _c.serializedDeletedNodes) === serializedDeletedNodes && trackState) {
+        if (((_c = this.latestSummaryData) === null || _c === void 0 ? void 0 : _c.serializedDeletedNodes) === serializedDeletedNodes &&
+            trackState) {
             builder.addHandle(gcDeletedBlobKey, SummaryType.Blob, `/${gcTreeKey}/${gcDeletedBlobKey}`);
         }
         else {
@@ -745,6 +782,7 @@ export class GarbageCollector {
              * into the metadata blob. If GC is disabled, the gcFeature is 0.
              */
             gcFeature: this.gcEnabled ? this.currentGCVersion : 0,
+            gcFeatureMatrix: this.persistedGcFeatureMatrix,
             sessionExpiryTimeoutMs: this.sessionExpiryTimeoutMs,
             sweepEnabled: this.sweepEnabled,
             sweepTimeoutMs: this.sweepTimeoutMs,
@@ -761,7 +799,7 @@ export class GarbageCollector {
      * Called to refresh the latest summary state. This happens when either a pending summary is acked or a snapshot
      * is downloaded and should be used to update the state.
      */
-    async refreshLatestSummary(result, proposalHandle, summaryRefSeq, readAndParseBlob) {
+    async refreshLatestSummary(proposalHandle, result, readAndParseBlob) {
         // If the latest summary was updated and the summary was tracked, this client is the one that generated this
         // summary. So, update wasGCRunInLatestSummary.
         // Note that this has to be updated if GC did not run too. Otherwise, `gcStateNeedsReset` will always return
@@ -783,8 +821,8 @@ export class GarbageCollector {
             return;
         }
         // If the summary was not tracked by this client, the state should be updated from the downloaded snapshot.
-        const snapshot = result.snapshot;
-        const metadataBlobId = snapshot.blobs[metadataBlobName];
+        const snapshotTree = result.snapshotTree;
+        const metadataBlobId = snapshotTree.blobs[metadataBlobName];
         if (metadataBlobId) {
             const metadata = await readAndParseBlob(metadataBlobId);
             this.latestSummaryGCVersion = getGCVersion(metadata);
@@ -793,9 +831,13 @@ export class GarbageCollector {
         // to be at least one op (summary op / ack, if nothing else) if a snapshot was taken.
         const currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs();
         if (currentReferenceTimestampMs === undefined) {
-            throw DataProcessingError.create("No reference timestamp when updating GC state from snapshot", "refreshLatestSummary", undefined, { proposalHandle, summaryRefSeq, details: JSON.stringify(this.configs) });
+            throw DataProcessingError.create("No reference timestamp when updating GC state from snapshot", "refreshLatestSummary", undefined, {
+                proposalHandle,
+                summaryRefSeq: result.summaryRefSeq,
+                details: JSON.stringify(this.configs),
+            });
         }
-        const gcSnapshotTree = snapshot.trees[gcTreeKey];
+        const gcSnapshotTree = snapshotTree.trees[gcTreeKey];
         // If GC ran in the container that generated this snapshot, it will have a GC tree.
         this.wasGCRunInLatestSummary = gcSnapshotTree !== undefined;
         let latestGCData;
@@ -850,12 +892,12 @@ export class GarbageCollector {
             else if (nodeType === GCNodeType.Blob) {
                 eventName = "GC_Tombstone_Blob_Revived";
             }
-            sendGCTombstoneEvent(this.mc, {
+            sendGCUnexpectedUsageEvent(this.mc, {
                 eventName,
                 category: "generic",
-                isSummarizerClient: this.isSummarizerClient,
                 url: trimLeadingSlashes(toNodePath),
                 nodeType,
+                gcTombstoneEnforcementAllowed: this.runtime.gcTombstoneEnforcementAllowed,
             }, undefined /* packagePath */);
         }
     }
@@ -879,13 +921,16 @@ export class GarbageCollector {
      * @param gcData - The data representing the reference graph on which GC is run.
      * @param gcResult - The result of the GC run on the gcData.
      * @param currentReferenceTimestampMs - The timestamp to be used for unreferenced nodes' timestamp.
+     * @returns - A list of sweep ready nodes. (Nodes ready to be deleted)
      */
-    updateCurrentState(gcData, gcResult, currentReferenceTimestampMs) {
-        this.gcDataFromLastRun = cloneGCData(gcData);
-        this.tombstones = [];
+    updateMarkPhase(gcData, gcResult, currentReferenceTimestampMs, logger) {
+        var _a;
+        // Get references from the current GC run + references between previous and current run and then update each
+        // node's state
+        const allNodesReferencedBetweenGCs = (_a = this.findAllNodesReferencedBetweenGCs(gcData, this.gcDataFromLastRun, logger)) !== null && _a !== void 0 ? _a : gcResult.referencedNodeIds;
         this.newReferencesSinceLastRun.clear();
         // Iterate through the referenced nodes and stop tracking if they were unreferenced before.
-        for (const nodeId of gcResult.referencedNodeIds) {
+        for (const nodeId of allNodesReferencedBetweenGCs) {
             const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
             if (nodeStateTracker !== undefined) {
                 // Stop tracking so as to clear out any running timers.
@@ -898,7 +943,10 @@ export class GarbageCollector {
          * If a node became unreferenced in this run, start tracking it.
          * If a node was already unreferenced, update its tracking information. Since the current reference time is
          * from the ops seen, this will ensure that we keep updating the unreferenced state as time moves forward.
+         *
+         * If a node is sweep ready, store and then return it.
          */
+        const sweepReadyNodes = [];
         for (const nodeId of gcResult.deletedNodeIds) {
             const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
             if (nodeStateTracker === undefined) {
@@ -906,14 +954,51 @@ export class GarbageCollector {
             }
             else {
                 nodeStateTracker.updateTracking(currentReferenceTimestampMs);
-                if (this.tombstoneMode && nodeStateTracker.state === UnreferencedState.SweepReady) {
-                    const nodeType = this.runtime.getNodeType(nodeId);
-                    if (nodeType === GCNodeType.DataStore || nodeType === GCNodeType.Blob) {
-                        this.tombstones.push(nodeId);
-                    }
+                if (nodeStateTracker.state === UnreferencedState.SweepReady) {
+                    sweepReadyNodes.push(nodeId);
                 }
             }
         }
+        return sweepReadyNodes;
+    }
+    /**
+     * Deletes nodes from both the runtime and garbage collection
+     * @param sweepReadyNodes - nodes that are ready to be deleted
+     */
+    runSweepPhase(sweepReadyNodes, gcData) {
+        // TODO: GC:Validation - validate that removed routes are not double deleted
+        // TODO: GC:Validation - validate that the child routes of removed routes are deleted as well
+        const sweptRoutes = this.runtime.deleteUnusedNodes(sweepReadyNodes);
+        const updatedGCData = this.deleteSweptRoutes(sweptRoutes, gcData);
+        for (const nodeId of sweptRoutes) {
+            const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
+            // TODO: GC:Validation - assert that the nodeStateTracker is defined
+            if (nodeStateTracker !== undefined) {
+                // Stop tracking so as to clear out any running timers.
+                nodeStateTracker.stopTracking();
+                // Delete the node as we don't need to track it any more.
+                this.unreferencedNodesState.delete(nodeId);
+            }
+            // TODO: GC:Validation - assert that the deleted node is not a duplicate
+            this.deletedNodes.add(nodeId);
+        }
+        return updatedGCData;
+    }
+    /**
+     * @returns IGarbageCollectionData after deleting the sweptRoutes from the gcData
+     */
+    deleteSweptRoutes(sweptRoutes, gcData) {
+        const sweptRoutesSet = new Set(sweptRoutes);
+        const gcNodes = {};
+        for (const [id, outboundRoutes] of Object.entries(gcData.gcNodes)) {
+            if (!sweptRoutesSet.has(id)) {
+                gcNodes[id] = Array.from(outboundRoutes);
+            }
+        }
+        // TODO: GC:Validation - assert that the nodeId is in gcData
+        return {
+            gcNodes,
+        };
     }
     /**
      * Since GC runs periodically, the GC data that is generated only tells us the state of the world at that point in
@@ -925,16 +1010,19 @@ export class GarbageCollector {
      * 2. A reference is added from one unreferenced node to one or more unreferenced nodes. Even though the node[s] were
      * unreferenced, they could have been accessed and in-memory reference to them added.
      *
-     * This function identifies nodes that were referenced since last run and removes their unreferenced state, if any.
+     * This function identifies nodes that were referenced since the last run.
      * If these nodes are currently unreferenced, they will be assigned new unreferenced state by the current run.
+     *
+     * @returns - a list of all nodes referenced from the last local summary until now.
      */
-    updateStateSinceLastRun(currentGCData, logger) {
+    findAllNodesReferencedBetweenGCs(currentGCData, previousGCData, logger) {
         // If we haven't run GC before there is nothing to do.
-        if (this.gcDataFromLastRun === undefined) {
-            return;
+        // No previousGCData, means nothing is unreferenced, and there are no reference state trackers to clear
+        if (previousGCData === undefined) {
+            return undefined;
         }
         // Find any references that haven't been identified correctly.
-        const missingExplicitReferences = this.findMissingExplicitReferences(currentGCData, this.gcDataFromLastRun, this.newReferencesSinceLastRun);
+        const missingExplicitReferences = this.findMissingExplicitReferences(currentGCData, previousGCData, this.newReferencesSinceLastRun);
         if (missingExplicitReferences.length > 0) {
             missingExplicitReferences.forEach((missingExplicitReference) => {
                 logger.sendErrorEvent({
@@ -945,9 +1033,9 @@ export class GarbageCollector {
             });
         }
         // No references were added since the last run so we don't have to update reference states of any unreferenced
-        // nodes
+        // nodes. There is no in between state at this point.
         if (this.newReferencesSinceLastRun.size === 0) {
-            return;
+            return undefined;
         }
         /**
          * Generate a super set of the GC data that contains the nodes and edges from last run, plus any new node and
@@ -965,7 +1053,7 @@ export class GarbageCollector {
          * - We don't require DDSes handles to be stored in a referenced DDS.
          * - A new data store may have "root" DDSes already created and we don't detect them today.
          */
-        const gcDataSuperSet = concatGarbageCollectionData(this.gcDataFromLastRun, currentGCData);
+        const gcDataSuperSet = concatGarbageCollectionData(previousGCData, currentGCData);
         const newOutboundRoutesSinceLastRun = [];
         this.newReferencesSinceLastRun.forEach((outboundRoutes, sourceNodeId) => {
             if (gcDataSuperSet.gcNodes[sourceNodeId] === undefined) {
@@ -983,16 +1071,11 @@ export class GarbageCollector {
          * Note that some of these nodes may be unreferenced now and if so, the current run will mark them as
          * unreferenced and add unreferenced state.
          */
-        const gcResult = runGarbageCollection(gcDataSuperSet.gcNodes, ["/", ...newOutboundRoutesSinceLastRun]);
-        for (const nodeId of gcResult.referencedNodeIds) {
-            const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
-            if (nodeStateTracker !== undefined) {
-                // Stop tracking so as to clear out any running timers.
-                nodeStateTracker.stopTracking();
-                // Delete the unreferenced state as we don't need to track it any more.
-                this.unreferencedNodesState.delete(nodeId);
-            }
-        }
+        const gcResult = runGarbageCollection(gcDataSuperSet.gcNodes, [
+            "/",
+            ...newOutboundRoutesSinceLastRun,
+        ]);
+        return gcResult.referencedNodeIds;
     }
     /**
      * Finds all new references or outbound routes in the current graph that haven't been explicitly notified to GC.
@@ -1008,7 +1091,7 @@ export class GarbageCollector {
      * @returns - a list of missing explicit references
      */
     findMissingExplicitReferences(currentGCData, previousGCData, explicitReferences) {
-        assert(previousGCData !== undefined, 0x2b7);
+        assert(previousGCData !== undefined, 0x2b7 /* "Can't validate correctness without GC data from last run" */);
         const currentGraph = Object.entries(currentGCData.gcNodes);
         const missingExplicitReferences = [];
         currentGraph.forEach(([nodeId, currentOutboundRoutes]) => {
@@ -1026,9 +1109,10 @@ export class GarbageCollector {
              */
             currentOutboundRoutes.forEach((route) => {
                 const nodeType = this.runtime.getNodeType(route);
-                if ((nodeType === GCNodeType.DataStore || nodeType === GCNodeType.Blob)
-                    && !nodeId.startsWith(route)
-                    && (!previousRoutes.includes(route) && !explicitRoutes.includes(route))) {
+                if ((nodeType === GCNodeType.DataStore || nodeType === GCNodeType.Blob) &&
+                    !nodeId.startsWith(route) &&
+                    !previousRoutes.includes(route) &&
+                    !explicitRoutes.includes(route)) {
                     missingExplicitRoutes.push(route);
                 }
             });
@@ -1100,7 +1184,8 @@ export class GarbageCollector {
      * this will give us a view into how much deleted content a container has.
      */
     logSweepEvents(logger, currentReferenceTimestampMs) {
-        if (this.mc.config.getBoolean(disableSweepLogKey) === true || this.sweepTimeoutMs === undefined) {
+        if (this.mc.config.getBoolean(disableSweepLogKey) === true ||
+            this.sweepTimeoutMs === undefined) {
             return;
         }
         this.unreferencedNodesState.forEach((nodeStateTracker, nodeId) => {
@@ -1135,7 +1220,8 @@ export class GarbageCollector {
         // If there is no reference timestamp to work with, no ops have been processed after creation. If so, skip
         // logging as nothing interesting would have happened worth logging.
         // If the node is active, skip logging.
-        if (currentReferenceTimestampMs === undefined || nodeStateTracker.state === UnreferencedState.Active) {
+        if (currentReferenceTimestampMs === undefined ||
+            nodeStateTracker.state === UnreferencedState.Active) {
             return;
         }
         // We only care about data stores and attachment blobs for this telemetry since GC only marks these objects
@@ -1200,11 +1286,18 @@ export class GarbageCollector {
              * revived and a Revived event will be logged for it.
              */
             const nodeStateTracker = this.unreferencedNodesState.get(eventProps.id);
-            const active = nodeStateTracker === undefined || nodeStateTracker.state === UnreferencedState.Active;
+            const active = nodeStateTracker === undefined ||
+                nodeStateTracker.state === UnreferencedState.Active;
             if ((usageType === "Revived") === active) {
                 const pkg = await this.getNodePackagePath(eventProps.id);
-                const fromPkg = eventProps.fromId ? await this.getNodePackagePath(eventProps.fromId) : undefined;
-                const event = Object.assign(Object.assign({}, propsToLog), { eventName: `${state}Object_${usageType}`, pkg: pkg ? { value: pkg.join("/"), tag: TelemetryDataTag.CodeArtifact } : undefined, fromPkg: fromPkg ? { value: fromPkg.join("/"), tag: TelemetryDataTag.CodeArtifact } : undefined });
+                const fromPkg = eventProps.fromId
+                    ? await this.getNodePackagePath(eventProps.fromId)
+                    : undefined;
+                const event = Object.assign(Object.assign({}, propsToLog), { eventName: `${state}Object_${usageType}`, pkg: pkg
+                        ? { value: pkg.join("/"), tag: TelemetryDataTag.CodeArtifact }
+                        : undefined, fromPkg: fromPkg
+                        ? { value: fromPkg.join("/"), tag: TelemetryDataTag.CodeArtifact }
+                        : undefined });
                 if (state === UnreferencedState.Inactive) {
                     logger.sendTelemetryEvent(event);
                 }
@@ -1230,7 +1323,9 @@ function generateSortedGCState(gcState) {
 class TimerWithNoDefaultTimeout extends Timer {
     constructor(callback) {
         // The default timeout/handlers will never be used since start/restart pass overrides below
-        super(0, () => { throw new Error("DefaultHandler should not be used"); });
+        super(0, () => {
+            throw new Error("DefaultHandler should not be used");
+        });
         this.callback = callback;
     }
     start(timeoutMs) {