@fluidframework/container-runtime 2.0.0-dev.3.1.0.125672 → 2.0.0-dev.4.1.0.148229

package/lib/{garbageCollection.js → gc/garbageCollection.js}

@@ -14,105 +14,17 @@ 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 { cloneGCData, concatGarbageCollectionData, getGCDataFromSnapshot, runGarbageCollection, trimLeadingSlashes, } from "@fluidframework/garbage-collector";
-import { SummaryType } from "@fluidframework/protocol-definitions";
-import { gcTreeKey, gcBlobPrefix, gcTombstoneBlobKey, gcDeletedBlobKey, } from "@fluidframework/runtime-definitions";
-import { mergeStats, packagePathToTelemetryProperty, SummaryTreeBuilder, } from "@fluidframework/runtime-utils";
+import { ClientSessionExpiredError, DataProcessingError } from "@fluidframework/container-utils";
+import { gcTreeKey, } from "@fluidframework/runtime-definitions";
+import { packagePathToTelemetryProperty } from "@fluidframework/runtime-utils";
 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 { sendGCUnexpectedUsageEvent } from "./garbageCollectionHelpers";
-import { SweepReadyUsageDetectionHandler } from "./gcSweepReadyUsageDetection";
-import { getGCVersion, metadataBlobName, dataStoreAttributesBlobName, } from "./summaryFormat";
-/** The types of GC nodes in the GC reference graph. */
-export const GCNodeType = {
-    // Nodes that are for data stores.
-    DataStore: "DataStore",
-    // Nodes that are within a data store. For example, DDS nodes.
-    SubDataStore: "SubDataStore",
-    // Nodes that are for attachment blobs, i.e., blobs uploaded via BlobManager.
-    Blob: "Blob",
-    // Nodes that are neither of the above. For example, root node.
-    Other: "Other",
-};
-/** The state of node that is unreferenced. */
-export const UnreferencedState = {
-    /** The node is active, i.e., it can become referenced again. */
-    Active: "Active",
-    /** The node is inactive, i.e., it should not become referenced. */
-    Inactive: "Inactive",
-    /** The node is ready to be deleted by the sweep phase. */
-    SweepReady: "SweepReady",
-};
-/**
- * Helper class that tracks the state of an unreferenced node such as the time it was unreferenced and if it can
- * be deleted by the sweep phase.
- */
-export class UnreferencedStateTracker {
-    constructor(unreferencedTimestampMs, 
-    /** The time after which node transitions to Inactive state. */
-    inactiveTimeoutMs, 
-    /** The current reference timestamp used to track how long this node has been unreferenced for. */
-    currentReferenceTimestampMs, 
-    /** The time after which node transitions to SweepReady state; undefined if session expiry is disabled. */
-    sweepTimeoutMs) {
-        this.unreferencedTimestampMs = unreferencedTimestampMs;
-        this.inactiveTimeoutMs = inactiveTimeoutMs;
-        this.sweepTimeoutMs = sweepTimeoutMs;
-        this._state = UnreferencedState.Active;
-        if (this.sweepTimeoutMs !== undefined) {
-            assert(this.inactiveTimeoutMs <= this.sweepTimeoutMs, 0x3b0 /* inactive timeout must not be greater than the sweep timeout */);
-        }
-        this.sweepTimer = new TimerWithNoDefaultTimeout(() => {
-            this._state = UnreferencedState.SweepReady;
-            assert(!this.inactiveTimer.hasTimer, 0x3b1 /* inactiveTimer still running after sweepTimer fired! */);
-        });
-        this.inactiveTimer = new TimerWithNoDefaultTimeout(() => {
-            this._state = UnreferencedState.Inactive;
-            // After the node becomes inactive, start the sweep timer after which the node will be ready for sweep.
-            if (this.sweepTimeoutMs !== undefined) {
-                this.sweepTimer.restart(this.sweepTimeoutMs - this.inactiveTimeoutMs);
-            }
-        });
-        this.updateTracking(currentReferenceTimestampMs);
-    }
-    get state() {
-        return this._state;
-    }
-    /* Updates the unreferenced state based on the provided timestamp. */
-    updateTracking(currentReferenceTimestampMs) {
-        const unreferencedDurationMs = currentReferenceTimestampMs - this.unreferencedTimestampMs;
-        // If the node has been unreferenced for sweep timeout amount of time, update the state to SweepReady.
-        if (this.sweepTimeoutMs !== undefined && unreferencedDurationMs >= this.sweepTimeoutMs) {
-            this._state = UnreferencedState.SweepReady;
-            this.clearTimers();
-            return;
-        }
-        // If the node has been unreferenced for inactive timeoutMs amount of time, update the state to inactive.
-        // Also, start a timer for the sweep timeout.
-        if (unreferencedDurationMs >= this.inactiveTimeoutMs) {
-            this._state = UnreferencedState.Inactive;
-            this.inactiveTimer.clear();
-            if (this.sweepTimeoutMs !== undefined) {
-                this.sweepTimer.restart(this.sweepTimeoutMs - unreferencedDurationMs);
-            }
-            return;
-        }
-        // The node is still active. Ensure the inactive timer is running with the proper remaining duration.
-        this.inactiveTimer.restart(this.inactiveTimeoutMs - unreferencedDurationMs);
-    }
-    clearTimers() {
-        this.inactiveTimer.clear();
-        this.sweepTimer.clear();
-    }
-    /** Stop tracking this node. Reset the unreferenced timers and state, if any. */
-    stopTracking() {
-        this.clearTimers();
-        this._state = UnreferencedState.Active;
-    }
-}
+import { RuntimeHeaders } from "../containerRuntime";
+import { generateGCConfigs } from "./gcConfigs";
+import { disableSweepLogKey, GCNodeType, UnreferencedState, } from "./gcDefinitions";
+import { cloneGCData, concatGarbageCollectionData, getGCDataFromSnapshot, sendGCUnexpectedUsageEvent, } from "./gcHelpers";
+import { runGarbageCollection } from "./gcReferenceGraphAlgorithm";
+import { GCSummaryStateTracker } from "./gcSummaryStateTracker";
+import { UnreferencedStateTracker } from "./gcUnreferencedStateTracker";
 /**
  * The garbage collector for the container runtime. It consolidates the garbage collection functionality and maintains
  * its state across summaries.
@@ -124,20 +36,19 @@ 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 {
     constructor(createParams) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
         // Keeps a list of references (edges in the GC graph) between GC runs. Each entry has a node id and a list of
         // outbound routes from that node.
         this.newReferencesSinceLastRun = new Map();
@@ -156,194 +67,61 @@ export class GarbageCollector {
         this.completedRuns = 0;
         this.runtime = createParams.runtime;
         this.isSummarizerClient = createParams.isSummarizerClient;
-        this.gcOptions = createParams.gcOptions;
         this.createContainerMetadata = createParams.createContainerMetadata;
         this.getNodePackagePath = createParams.getNodePackagePath;
         this.getLastSummaryTimestampMs = createParams.getLastSummaryTimestampMs;
         this.activeConnection = createParams.activeConnection;
         const baseSnapshot = createParams.baseSnapshot;
-        const metadata = createParams.metadata;
         const readAndParseBlob = createParams.readAndParseBlob;
         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.sweepReadyUsageHandler = new SweepReadyUsageDetectionHandler(createParams.getContainerDiagnosticId(), this.mc, this.runtime.closeFn);
-        let prevSummaryGCVersion;
-        /**
-         * Sweep timeout is the time after which unreferenced content can be swept.
-         * Sweep timeout = session expiry timeout + snapshot cache expiry timeout + one day buffer.
-         *
-         * The snapshot cache expiry timeout cannot be known precisely but the upper bound is 5 days.
-         * The buffer is added to account for any clock skew or other edge cases.
-         * We use server timestamps throughout so the skew should be minimal but make it 1 day to be safe.
-         */
-        function computeSweepTimeout(sessionExpiryTimeoutMs) {
-            const maxSnapshotCacheExpiryMs = 5 * oneDayMs;
-            const bufferMs = oneDayMs;
-            return (sessionExpiryTimeoutMs &&
-                sessionExpiryTimeoutMs + maxSnapshotCacheExpiryMs + bufferMs);
-        }
-        /**
-         * The following GC state is enabled during container creation and cannot be changed throughout its lifetime:
-         * 1. Whether running GC mark phase is allowed or not.
-         * 2. Whether running GC sweep phase is allowed or not.
-         * 3. Whether GC session expiry is enabled or not.
-         * For existing containers, we get this information from the metadata blob of its summary.
-         */
-        if (createParams.existing) {
-            prevSummaryGCVersion = getGCVersion(metadata);
-            // Existing documents which did not have metadata blob or had GC disabled have version as 0. For all
-            // other existing documents, GC is enabled.
-            this.gcEnabled = prevSummaryGCVersion > 0;
-            this.sweepEnabled = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.sweepEnabled) !== null && _a !== void 0 ? _a : false;
-            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
-        }
-        else {
-            // Sweep should not be enabled without enabling GC mark phase. We could silently disable sweep in this
-            // scenario but explicitly failing makes it clearer and promotes correct usage.
-            if (this.gcOptions.sweepAllowed && this.gcOptions.gcAllowed === false) {
-                throw new UsageError("GC sweep phase cannot be enabled without enabling GC mark phase");
-            }
-            // This Test Override only applies for new containers
-            const testOverrideSweepTimeoutMs = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.SweepTimeoutMs");
-            // For new documents, GC is enabled by default. It can be explicitly disabled by setting the gcAllowed
-            // flag in GC options to false.
-            this.gcEnabled = this.gcOptions.gcAllowed !== false;
-            // The sweep phase has to be explicitly enabled by setting the sweepAllowed flag in GC options to true.
-            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.sweepTimeoutMs =
-                testOverrideSweepTimeoutMs !== null && testOverrideSweepTimeoutMs !== void 0 ? testOverrideSweepTimeoutMs : computeSweepTimeout(this.sessionExpiryTimeoutMs);
-        }
+        this.configs = generateGCConfigs(this.mc, createParams);
         // If session expiry is enabled, we need to close the container when the session expiry timeout expires.
-        if (this.sessionExpiryTimeoutMs !== undefined) {
+        if (this.configs.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;
+            const timeoutMs = overrideSessionExpiryTimeoutMs !== null && overrideSessionExpiryTimeoutMs !== void 0 ? overrideSessionExpiryTimeoutMs : this.configs.sessionExpiryTimeoutMs;
             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
-        // latest tracked GC version. For new documents, we will be writing the first summary with the current version.
-        this.latestSummaryGCVersion = prevSummaryGCVersion !== null && prevSummaryGCVersion !== void 0 ? prevSummaryGCVersion : this.currentGCVersion;
-        /**
-         * Whether GC should run or not. The following conditions have to be met to run sweep:
-         *
-         * 1. GC should be enabled for this container.
-         *
-         * 2. GC should not be disabled via disableGC GC option.
-         *
-         * 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);
-        /**
-         * Whether sweep should run or not. The following conditions have to be met to run sweep:
-         *
-         * 1. Overall GC or mark phase must be enabled (this.shouldRunGC).
-         * 2. Sweep timeout should be available. Without this, we wouldn't know when an object should be deleted.
-         * 3. The driver must implement the policy limiting the age of snapshots used for loading. Otherwise
-         * the Sweep Timeout calculation is not valid. We use the persisted value to ensure consistency over time.
-         * 4. Sweep should be enabled for this container (this.sweepEnabled). This can be overridden via runSweep
-         * feature flag.
-         */
-        this.shouldRunSweep =
-            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;
-        // 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;
-        // 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;
-        // 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;
+        this.summaryStateTracker = new GCSummaryStateTracker(this.configs, (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[gcTreeKey]) !== undefined /* wasGCRunInBaseSnapshot */);
         // Get the GC data from the base snapshot. Use LazyPromise because we only want to do this once since it
         // it involves fetching blobs from storage which is expensive.
         this.baseSnapshotDataP = new LazyPromise(async () => {
-            var _a;
             if (baseSnapshot === undefined) {
                 return undefined;
             }
             try {
                 // For newer documents, GC data should be present in the GC tree in the root of the snapshot.
                 const gcSnapshotTree = baseSnapshot.trees[gcTreeKey];
-                if (gcSnapshotTree !== undefined) {
-                    return getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob);
+                if (gcSnapshotTree === undefined) {
+                    // back-compat - Older documents get their gc data reset for simplicity as there are few of them
+                    // incremental gc summary will not work with older gc data as well
+                    return undefined;
                 }
-                // 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 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)) {
-                    const blobId = dsSnapshotTree.blobs[gcTreeKey];
-                    if (blobId === undefined) {
-                        continue;
-                    }
-                    const gcSummaryDetails = await readAndParseBlob(blobId);
-                    // If there are no nodes for this data store, skip it.
-                    if (((_a = gcSummaryDetails.gcData) === null || _a === void 0 ? void 0 : _a.gcNodes) === undefined) {
-                        continue;
-                    }
-                    const dsRootId = `/${dsId}`;
-                    // Since we used to write GC data at data store level, we won't have an entry for the root ("/").
-                    // Construct that entry by adding root data store ids to its outbound routes.
-                    const initialSnapshotDetails = await readAndParseBlob(dsSnapshotTree.blobs[dataStoreAttributesBlobName]);
-                    if (initialSnapshotDetails.isRootDataStore) {
-                        gcState.gcNodes["/"].outboundRoutes.push(dsRootId);
-                    }
-                    for (const [id, outboundRoutes] of Object.entries(gcSummaryDetails.gcData.gcNodes)) {
-                        // 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),
-                        };
-                    }
-                    assert(gcState.gcNodes[dsRootId] !== undefined, 0x2a9 /* GC nodes for data store not in GC blob */);
-                    gcState.gcNodes[dsRootId].unreferencedTimestampMs =
-                        gcSummaryDetails.unrefTimestamp;
+                const snapshotData = await getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob);
+                // If the GC version in base snapshot does not match the GC version currently in effect, the GC data
+                // in the snapshot cannot be interpreted correctly. Set everything to undefined except for
+                // deletedNodes because irrespective of GC versions, these nodes have been deleted and cannot be
+                // brought back. The deletedNodes info is needed to identify when these nodes are used.
+                if (this.configs.gcVersionInBaseSnapshot !==
+                    this.summaryStateTracker.currentGCVersion) {
+                    return {
+                        gcState: undefined,
+                        tombstones: undefined,
+                        deletedNodes: snapshotData.deletedNodes,
+                    };
                 }
-                // 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.
-                return Object.keys(gcState.gcNodes).length === 1
-                    ? undefined
-                    : { gcState, tombstones: undefined, deletedNodes: undefined };
+                return snapshotData;
             }
             catch (error) {
                 const dpe = DataProcessingError.wrapIfUnrecognized(error, "FailedToInitializeGC");
-                dpe.addTelemetryProperties({ gcConfigs: JSON.stringify(this.configs) });
+                dpe.addTelemetryProperties({
+                    gcConfigs: JSON.stringify(this.configs),
+                });
                 throw dpe;
             }
         });
@@ -381,12 +159,13 @@ export class GarbageCollector {
                 return;
             }
             this.updateStateFromSnapshotData(baseSnapshotData, currentReferenceTimestampMs);
+            this.summaryStateTracker.initializeBaseState(baseSnapshotData);
         });
         // Get the GC details from the GC state in the base summary. This is returned in getBaseGCDetails which is
         // used to initialize the GC state of all the nodes in the container.
         this.baseGCDetailsP = new LazyPromise(async () => {
             const baseSnapshotData = await this.baseSnapshotDataP;
-            if (baseSnapshotData === undefined) {
+            if ((baseSnapshotData === null || baseSnapshotData === void 0 ? void 0 : baseSnapshotData.gcState) === undefined) {
                 return {};
             }
             const gcNodes = {};
@@ -405,51 +184,18 @@ export class GarbageCollector {
             this.mc.logger.sendTelemetryEvent({
                 eventName: "GarbageCollectorLoaded",
                 gcConfigs: JSON.stringify(this.configs),
+                gcOptions: JSON.stringify(createParams.gcOptions),
             });
         }
     }
     static create(createParams) {
         return new GarbageCollector(createParams);
     }
-    /**
-     * Tells whether the GC state needs to be reset in the next summary. We need to do this if:
-     *
-     * 1. GC was enabled and is now disabled. The GC state needs to be removed and everything becomes referenced.
-     *
-     * 2. GC was disabled and is now enabled. The GC state needs to be regenerated and added to summary.
-     *
-     * 3. GC is enabled and the latest summary state is refreshed from a snapshot that had GC disabled and vice-versa.
-     *
-     * 4. The GC version in the latest summary is different from the current GC version. This can happen if:
-     *
-     * 4.1. The summary this client loaded with has data from a different GC version.
-     *
-     * 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));
+    get shouldRunGC() {
+        return this.configs.shouldRunGC;
     }
-    /**
-     * Tells whether the GC state needs to be reset. This can happen under 3 conditions:
-     *
-     * 1. The base snapshot contains GC state but GC is disabled. This will happen the first time GC is disabled after
-     * it was enabled before. GC state needs to be removed from summary and all nodes should be marked referenced.
-     *
-     * 2. The base snapshot does not have GC state but GC is enabled. This will happen the very first time GC runs on
-     * a document and the first time GC is enabled after is was disabled before.
-     *
-     * 3. GC is enabled and the latest summary state is refreshed from a snapshot that had GC disabled and vice-versa.
-     *
-     * 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;
-    }
-    /** Returns a list of all the configurations for garbage collection. */
-    get configs() {
-        return Object.assign({ gcEnabled: this.gcEnabled, sweepEnabled: this.sweepEnabled, runGC: this.shouldRunGC, runSweep: this.shouldRunSweep, testMode: this.testMode, tombstoneMode: this.tombstoneMode, sessionExpiry: this.sessionExpiryTimeoutMs, sweepTimeout: this.sweepTimeoutMs, inactiveTimeout: this.inactiveTimeoutMs, trackGCState: this.trackGCState }, this.gcOptions);
+    get summaryStateNeedsReset() {
+        return this.summaryStateTracker.doesSummaryStateNeedReset;
     }
     /**
      * Called during container initialization. Initialize from the tombstone state in the base snapshot. This is done
@@ -473,7 +219,8 @@ 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) {
+        if (this.configs.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);
         }
@@ -507,9 +254,9 @@ export class GarbageCollector {
         // tombstones.
         // 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)
+        if (this.configs.shouldRunSweep) {
+            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.
@@ -525,16 +272,15 @@ export class GarbageCollector {
                 }
             }
         }
-        else if (this.tombstoneMode) {
+        else if (this.configs.tombstoneMode) {
             // The snapshot may contain more or fewer tombstone nodes than this client. Update tombstone state and
             // notify the runtime to update its state as well.
             this.tombstones = (snapshotData === null || snapshotData === void 0 ? void 0 : snapshotData.tombstones) ? Array.from(snapshotData.tombstones) : [];
             this.runtime.updateTombstonedRoutes(this.tombstones);
         }
         // If there is no snapshot data, it means this snapshot was generated with GC disabled. Unset all GC state.
-        if (snapshotData === undefined) {
+        if ((snapshotData === null || snapshotData === void 0 ? void 0 : snapshotData.gcState) === undefined) {
             this.gcDataFromLastRun = undefined;
-            this.latestSummaryData = undefined;
             return;
         }
         // Update unreferenced state tracking as per the GC state in the snapshot data and update gcDataFromLastRun
@@ -542,19 +288,11 @@ export class GarbageCollector {
         const gcNodes = {};
         for (const [nodeId, nodeData] of Object.entries(snapshotData.gcState.gcNodes)) {
             if (nodeData.unreferencedTimestampMs !== undefined) {
-                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.inactiveTimeoutMs, currentReferenceTimestampMs, this.sweepTimeoutMs));
+                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.configs.inactiveTimeoutMs, currentReferenceTimestampMs, this.configs.sweepTimeoutMs));
             }
             gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
         }
         this.gcDataFromLastRun = { gcNodes };
-        // If tracking state across summaries, update latest summary data from the snapshot's GC data.
-        if (this.trackGCState) {
-            this.latestSummaryData = {
-                serializedGCState: JSON.stringify(generateSortedGCState(snapshotData.gcState)),
-                serializedTombstones: JSON.stringify(snapshotData.tombstones),
-                serializedDeletedNodes: JSON.stringify(snapshotData.deletedNodes),
-            };
-        }
     }
     /**
      * Called when the connection state of the runtime changes, i.e., it connects or disconnects. GC subscribes to this
@@ -576,7 +314,7 @@ export class GarbageCollector {
          * Ideally, this initialization should only be done for summarizer client. However, we are currently rolling out
          * sweep in phases and we want to track when inactive and sweep ready objects are used in any client.
          */
-        if (this.activeConnection() && this.shouldRunGC) {
+        if (this.activeConnection() && this.configs.shouldRunGC) {
             this.initializeGCStateFromBaseSnapshotP.catch((error) => { });
         }
     }
@@ -584,9 +322,9 @@ export class GarbageCollector {
      * Runs garbage collection and updates the reference / used state of the nodes in the container.
      * @returns stats of the GC run or undefined if GC did not run.
      */
-    async collectGarbage(options) {
+    async collectGarbage(options, telemetryContext) {
         var _a;
-        const fullGC = (_a = options.fullGC) !== null && _a !== void 0 ? _a : (this.gcOptions.runFullGC === true || this.summaryStateNeedsReset);
+        const fullGC = (_a = options.fullGC) !== null && _a !== void 0 ? _a : (this.configs.runFullGC === true || this.summaryStateTracker.doesSummaryStateNeedReset);
         const logger = options.logger
             ? ChildLogger.create(options.logger, undefined, {
                 all: { completedGCRuns: () => this.completedRuns },
@@ -609,6 +347,11 @@ export class GarbageCollector {
             });
             return undefined;
         }
+        // Add the options that are used to run GC to the telemetry context.
+        telemetryContext === null || telemetryContext === void 0 ? void 0 : telemetryContext.setMultiple("fluid_GC", "Options", {
+            fullGC,
+            runSweep: options.runSweep,
+        });
         return PerformanceEvent.timedExecAsync(logger, { eventName: "GarbageCollection" }, async (event) => {
             await this.runPreGCSteps();
             // Get the runtime's GC data and run GC on the reference graph in it.
@@ -630,26 +373,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.configs.shouldRunSweep) {
+            updatedGCData = this.runSweepPhase(sweepReadyNodes, gcData);
+        }
+        else if (this.configs.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) {
+        else if (this.configs.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.
@@ -663,7 +409,7 @@ export class GarbageCollector {
      */
     summarize(fullTree, trackState, telemetryContext) {
         var _a;
-        if (!this.shouldRunGC || this.gcDataFromLastRun === undefined) {
+        if (!this.configs.shouldRunGC || this.gcDataFromLastRun === undefined) {
             return;
         }
         const gcState = { gcNodes: {} };
@@ -673,97 +419,7 @@ export class GarbageCollector {
                 unreferencedTimestampMs: (_a = this.unreferencedNodesState.get(nodeId)) === null || _a === void 0 ? void 0 : _a.unreferencedTimestampMs,
             };
         }
-        const serializedGCState = JSON.stringify(generateSortedGCState(gcState));
-        // Serialize and write deleted nodes, if any. This is done irrespective of whether sweep is enabled or not so
-        // to identify deleted nodes' usage.
-        const serializedDeletedNodes = this.deletedNodes.size > 0
-            ? JSON.stringify(Array.from(this.deletedNodes).sort())
-            : 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
-            : undefined;
-        /**
-         * Incremental summary of GC data - If none of GC state, deleted nodes or tombstones changed since last summary,
-         * write summary handle instead of summary tree for GC.
-         * Otherwise, write the GC summary tree. In the tree, for each of these that changed, write a summary blob and
-         * for each of these that did not change, write a summary handle.
-         */
-        if (this.trackGCState) {
-            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) {
-                    const stats = mergeStats();
-                    stats.handleNodeCount++;
-                    return {
-                        summary: {
-                            type: SummaryType.Handle,
-                            handle: `/${gcTreeKey}`,
-                            handleType: SummaryType.Tree,
-                        },
-                        stats,
-                    };
-                }
-                // If some state changed, build a GC summary tree.
-                return this.buildGCSummaryTree(serializedGCState, serializedTombstones, serializedDeletedNodes, true /* trackState */);
-            }
-        }
-        // If not tracking GC state, build a GC summary tree without any summary handles.
-        return this.buildGCSummaryTree(serializedGCState, serializedTombstones, serializedDeletedNodes, false /* trackState */);
-    }
-    /**
-     * Builds the GC summary tree which contains GC state, deleted nodes and tombstones.
-     * If trackState is false, all of GC state, deleted nodes and tombstones are written as summary blobs.
-     * If trackState is true, only states that changed are written. Rest are written as handles.
-     * @param serializedGCState - The GC state serialized as string.
-     * @param serializedTombstones - The tombstone state serialized as string.
-     * @param serializedDeletedNodes - Deleted nodes serialized as string.
-     * @param trackState - Whether we are tracking GC state across summaries.
-     * @returns the GC summary tree.
-     */
-    buildGCSummaryTree(serializedGCState, serializedTombstones, serializedDeletedNodes, trackState) {
-        var _a, _b, _c;
-        const gcStateBlobKey = `${gcBlobPrefix}_root`;
-        const builder = new SummaryTreeBuilder();
-        // If the GC state hasn't changed, write a summary handle, else write a summary blob for it.
-        if (((_a = this.latestSummaryData) === null || _a === void 0 ? void 0 : _a.serializedGCState) === serializedGCState && trackState) {
-            builder.addHandle(gcStateBlobKey, SummaryType.Blob, `/${gcTreeKey}/${gcStateBlobKey}`);
-        }
-        else {
-            builder.addBlob(gcStateBlobKey, serializedGCState);
-        }
-        // 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) {
-                builder.addHandle(gcTombstoneBlobKey, SummaryType.Blob, `/${gcTreeKey}/${gcTombstoneBlobKey}`);
-            }
-            else {
-                builder.addBlob(gcTombstoneBlobKey, serializedTombstones);
-            }
-        }
-        // If there are no deleted nodes, return the summary tree.
-        if (serializedDeletedNodes === undefined) {
-            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) {
-            builder.addHandle(gcDeletedBlobKey, SummaryType.Blob, `/${gcTreeKey}/${gcDeletedBlobKey}`);
-        }
-        else {
-            builder.addBlob(gcDeletedBlobKey, serializedDeletedNodes);
-        }
-        return builder.getSummaryTree();
+        return this.summaryStateTracker.summarize(fullTree, trackState, gcState, this.deletedNodes, this.tombstones);
     }
     getMetadata() {
         return {
@@ -771,10 +427,11 @@ export class GarbageCollector {
              * If GC is enabled, the GC data is written using the current GC version and that is the gcFeature that goes
              * into the metadata blob. If GC is disabled, the gcFeature is 0.
              */
-            gcFeature: this.gcEnabled ? this.currentGCVersion : 0,
-            sessionExpiryTimeoutMs: this.sessionExpiryTimeoutMs,
-            sweepEnabled: this.sweepEnabled,
-            sweepTimeoutMs: this.sweepTimeoutMs,
+            gcFeature: this.configs.gcEnabled ? this.summaryStateTracker.currentGCVersion : 0,
+            gcFeatureMatrix: this.configs.persistedGcFeatureMatrix,
+            sessionExpiryTimeoutMs: this.configs.sessionExpiryTimeoutMs,
+            sweepEnabled: false,
+            sweepTimeoutMs: this.configs.sweepTimeoutMs,
         };
     }
     /**
@@ -788,49 +445,23 @@ 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) {
-        // 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
-        // true in scenarios where GC is disabled but enabled in the snapshot we loaded from.
-        if (result.latestSummaryUpdated && result.wasSummaryTracked) {
-            this.wasGCRunInLatestSummary = this.shouldRunGC;
-        }
-        if (!result.latestSummaryUpdated || !this.shouldRunGC) {
-            return;
-        }
-        // If the summary was tracked by this client, it was the one that generated the summary in the first place.
-        // Update latest state from pending.
-        if (result.wasSummaryTracked) {
-            this.latestSummaryGCVersion = this.currentGCVersion;
-            if (this.trackGCState) {
-                this.latestSummaryData = this.pendingSummaryData;
-                this.pendingSummaryData = undefined;
+    async refreshLatestSummary(proposalHandle, result, readAndParseBlob) {
+        const latestSnapshotData = await this.summaryStateTracker.refreshLatestSummary(proposalHandle, result, readAndParseBlob);
+        // If the latest summary was updated but it was not tracked by this client, our state needs to be updated from
+        // this snapshot data.
+        if (this.shouldRunGC && result.latestSummaryUpdated && !result.wasSummaryTracked) {
+            // The current reference timestamp should be available if we are refreshing state from a snapshot. There has
+            // 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: result.summaryRefSeq,
+                    gcConfigs: JSON.stringify(this.configs),
+                });
             }
-            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];
-        if (metadataBlobId) {
-            const metadata = await readAndParseBlob(metadataBlobId);
-            this.latestSummaryGCVersion = getGCVersion(metadata);
-        }
-        // The current reference timestamp should be available if we are refreshing state from a snapshot. There has
-        // 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) });
+            this.updateStateFromSnapshotData(latestSnapshotData, currentReferenceTimestampMs);
         }
-        const gcSnapshotTree = snapshot.trees[gcTreeKey];
-        // If GC ran in the container that generated this snapshot, it will have a GC tree.
-        this.wasGCRunInLatestSummary = gcSnapshotTree !== undefined;
-        let latestGCData;
-        if (gcSnapshotTree !== undefined) {
-            latestGCData = await getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob);
-        }
-        this.updateStateFromSnapshotData(latestGCData, currentReferenceTimestampMs);
-        this.pendingSummaryData = undefined;
     }
     /**
      * Called when a node with the given id is updated. If the node is inactive, log an error.
@@ -841,7 +472,7 @@ export class GarbageCollector {
      * @param requestHeaders - If the node was loaded via request path, the headers in the request.
      */
     nodeUpdated(nodePath, reason, timestampMs, packagePath, requestHeaders) {
-        if (!this.shouldRunGC) {
+        if (!this.configs.shouldRunGC) {
             return;
         }
         const nodeStateTracker = this.unreferencedNodesState.get(nodePath);
@@ -858,7 +489,7 @@ export class GarbageCollector {
      */
     addedOutboundReference(fromNodePath, toNodePath) {
         var _a;
-        if (!this.shouldRunGC) {
+        if (!this.configs.shouldRunGC) {
             return;
         }
         const outboundRoutes = (_a = this.newReferencesSinceLastRun.get(fromNodePath)) !== null && _a !== void 0 ? _a : [];
@@ -880,9 +511,9 @@ export class GarbageCollector {
             sendGCUnexpectedUsageEvent(this.mc, {
                 eventName,
                 category: "generic",
-                isSummarizerClient: this.isSummarizerClient,
-                url: trimLeadingSlashes(toNodePath),
+                url: toNodePath,
                 nodeType,
+                gcTombstoneEnforcementAllowed: this.runtime.gcTombstoneEnforcementAllowed,
             }, undefined /* packagePath */);
         }
     }
@@ -906,13 +537,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.
@@ -925,22 +559,62 @@ 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) {
-                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(currentReferenceTimestampMs, this.inactiveTimeoutMs, currentReferenceTimestampMs, this.sweepTimeoutMs));
+                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(currentReferenceTimestampMs, this.configs.inactiveTimeoutMs, currentReferenceTimestampMs, this.configs.sweepTimeoutMs));
             }
             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.deleteSweepReadyNodes(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
@@ -952,16 +626,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({
@@ -972,9 +649,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
@@ -992,7 +669,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) {
@@ -1014,15 +691,7 @@ export class GarbageCollector {
             "/",
             ...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);
-            }
-        }
+        return gcResult.referencedNodeIds;
     }
     /**
      * Finds all new references or outbound routes in the current graph that haven't been explicitly notified to GC.
@@ -1132,7 +801,7 @@ export class GarbageCollector {
      */
     logSweepEvents(logger, currentReferenceTimestampMs) {
         if (this.mc.config.getBoolean(disableSweepLogKey) === true ||
-            this.sweepTimeoutMs === undefined) {
+            this.configs.sweepTimeoutMs === undefined) {
             return;
         }
         this.unreferencedNodesState.forEach((nodeStateTracker, nodeId) => {
@@ -1154,7 +823,7 @@ export class GarbageCollector {
                 id: nodeId,
                 type: nodeType,
                 age: currentReferenceTimestampMs - nodeStateTracker.unreferencedTimestampMs,
-                timeout: this.sweepTimeoutMs,
+                timeout: this.configs.sweepTimeoutMs,
                 completedGCRuns: this.completedRuns,
                 lastSummaryTime: this.getLastSummaryTimestampMs(),
             });
@@ -1184,8 +853,8 @@ export class GarbageCollector {
         }
         this.loggedUnreferencedEvents.add(uniqueEventId);
         const propsToLog = Object.assign(Object.assign({ id: nodeId, type: nodeType, unrefTime: nodeStateTracker.unreferencedTimestampMs, age: currentReferenceTimestampMs - nodeStateTracker.unreferencedTimestampMs, timeout: nodeStateTracker.state === UnreferencedState.Inactive
-                ? this.inactiveTimeoutMs
-                : this.sweepTimeoutMs, completedGCRuns: this.completedRuns, lastSummaryTime: this.getLastSummaryTimestampMs() }, this.createContainerMetadata), { externalRequest: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[RuntimeHeaders.externalRequest], viaHandle: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[RuntimeHeaders.viaHandle], fromId: fromNodeId });
+                ? this.configs.inactiveTimeoutMs
+                : this.configs.sweepTimeoutMs, completedGCRuns: this.completedRuns, lastSummaryTime: this.getLastSummaryTimestampMs() }, this.createContainerMetadata), { viaHandle: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[RuntimeHeaders.viaHandle], fromId: fromNodeId });
         // For summarizer client, queue the event so it is logged the next time GC runs if the event is still valid.
         // For non-summarizer client, log the event now since GC won't run on it. This may result in false positives
         // but it's a good signal nonetheless and we can consume it with a grain of salt.
@@ -1210,12 +879,6 @@ export class GarbageCollector {
                     this.mc.logger.sendErrorEvent(event);
                 }
             }
-            // If SweepReady Usage Detection is enabled, the handler may close the interactive container.
-            // Once Sweep is fully implemented, this will be removed since the objects will be gone
-            // and errors will arise elsewhere in the runtime
-            if (state === UnreferencedState.SweepReady) {
-                this.sweepReadyUsageHandler.usageDetectedInInteractiveClient(Object.assign(Object.assign({}, propsToLog), { usageType }));
-            }
         }
     }
     async logUnreferencedEvents(logger) {
@@ -1256,30 +919,4 @@ export class GarbageCollector {
         this.pendingEventsQueue = [];
     }
 }
-function generateSortedGCState(gcState) {
-    const sortableArray = Object.entries(gcState.gcNodes);
-    sortableArray.sort(([a], [b]) => a.localeCompare(b));
-    const sortedGCState = { gcNodes: {} };
-    for (const [nodeId, nodeData] of sortableArray) {
-        nodeData.outboundRoutes.sort();
-        sortedGCState.gcNodes[nodeId] = nodeData;
-    }
-    return sortedGCState;
-}
-/** A wrapper around common-utils Timer that requires the timeout when calling start/restart */
-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");
-        });
-        this.callback = callback;
-    }
-    start(timeoutMs) {
-        super.start(timeoutMs, this.callback);
-    }
-    restart(timeoutMs) {
-        super.restart(timeoutMs, this.callback);
-    }
-}
 //# sourceMappingURL=garbageCollection.js.map