@fluidframework/container-runtime 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.2.0.0.245554

package/src/dataStoreContexts.ts

@@ -6,8 +6,9 @@
 import { assert, Deferred, Lazy } from "@fluidframework/core-utils";
 import { IDisposable, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { createChildLogger, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
-import { FluidDataStoreContext, LocalFluidDataStoreContext } from "./dataStoreContext";
+import { FluidDataStoreContext, LocalFluidDataStoreContext } from "./dataStoreContext.js";
 
+/** @internal */
 export class DataStoreContexts implements Iterable<[string, FluidDataStoreContext]>, IDisposable {
 	private readonly notBoundContexts = new Set<string>();
 

package/src/deltaManagerSummarizerProxy.ts

@@ -3,11 +3,26 @@
  * Licensed under the MIT License.
  */
 
-import { IDeltaManager, ReadOnlyInfo } from "@fluidframework/container-definitions";
-import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import type {
+	IConnectionDetails,
+	IDeltaManager,
+	IDeltaManagerEvents,
+	IDeltaQueue,
+	IDeltaSender,
+	ReadOnlyInfo,
+} from "@fluidframework/container-definitions";
+import type { IErrorBase } from "@fluidframework/core-interfaces";
+import type { IAnyDriverError } from "@fluidframework/driver-definitions";
+import {
+	IClientConfiguration,
+	IClientDetails,
+	IDocumentMessage,
+	ISequencedDocumentMessage,
+	ISignalMessage,
+} from "@fluidframework/protocol-definitions";
 
-import { DeltaManagerProxyBase } from "./deltaManagerProxyBase";
-import { summarizerClientType } from "./summary";
+import { summarizerClientType } from "./summary/index.js";
 
 /**
  * Proxy to the real IDeltaManager for restricting certain access to layers below container runtime in summarizer clients:
@@ -15,9 +30,65 @@ import { summarizerClientType } from "./summary";
  * - Summarizer client should not be active to layers below the container runtime to restrict local changes.
  */
 export class DeltaManagerSummarizerProxy
-	extends DeltaManagerProxyBase
+	extends TypedEventEmitter<IDeltaManagerEvents>
 	implements IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>
 {
+	public get IDeltaSender(): IDeltaSender {
+		return this;
+	}
+
+	public get inbound(): IDeltaQueue<ISequencedDocumentMessage> {
+		return this.deltaManager.inbound;
+	}
+
+	public get outbound(): IDeltaQueue<IDocumentMessage[]> {
+		return this.deltaManager.outbound;
+	}
+
+	public get inboundSignal(): IDeltaQueue<ISignalMessage> {
+		return this.deltaManager.inboundSignal;
+	}
+
+	public get minimumSequenceNumber(): number {
+		return this.deltaManager.minimumSequenceNumber;
+	}
+
+	public get lastSequenceNumber(): number {
+		return this.deltaManager.lastSequenceNumber;
+	}
+
+	public get lastMessage() {
+		return this.deltaManager.lastMessage;
+	}
+
+	public get lastKnownSeqNumber() {
+		return this.deltaManager.lastKnownSeqNumber;
+	}
+
+	public get initialSequenceNumber(): number {
+		return this.deltaManager.initialSequenceNumber;
+	}
+
+	public get hasCheckpointSequenceNumber() {
+		return this.deltaManager.hasCheckpointSequenceNumber;
+	}
+
+	public get clientDetails(): IClientDetails {
+		return this.deltaManager.clientDetails;
+	}
+
+	public get version(): string {
+		return this.deltaManager.version;
+	}
+
+	public get maxMessageSize(): number {
+		return this.deltaManager.maxMessageSize;
+	}
+
+	public get serviceConfiguration(): IClientConfiguration | undefined {
+		return this.deltaManager.serviceConfiguration;
+	}
+
 	public get active(): boolean {
 		// Summarize clients should not be active. There shouldn't be any local changes (writes) in the summarizer
 		// except for the SummarizeOp which is generated by the runtime.
@@ -40,10 +111,64 @@ export class DeltaManagerSummarizerProxy
 
 	private readonly isSummarizerClient: boolean;
 
-	constructor(deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>) {
-		super(deltaManager);
+	constructor(
+		private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
+	) {
+		super();
+
 		// We are expecting this class to have many listeners, so we suppress noisy "MaxListenersExceededWarning" logging.
 		super.setMaxListeners(0);
 		this.isSummarizerClient = this.deltaManager.clientDetails.type === summarizerClientType;
+
+		this.deltaManager.on("prepareSend", this.onPrepareSend);
+		this.deltaManager.on("submitOp", this.onSubmitOp);
+		this.deltaManager.on("op", this.onOp);
+		this.deltaManager.on("pong", this.onPong);
+		this.deltaManager.on("connect", this.onConnect);
+		this.deltaManager.on("disconnect", this.onDisconnect);
+		this.deltaManager.on("readonly", this.onReadonly);
 	}
+
+	public dispose(): void {
+		this.deltaManager.off("prepareSend", this.onPrepareSend);
+		this.deltaManager.off("submitOp", this.onSubmitOp);
+		this.deltaManager.off("op", this.onOp);
+		this.deltaManager.off("pong", this.onPong);
+		this.deltaManager.off("connect", this.onConnect);
+		this.deltaManager.off("disconnect", this.onDisconnect);
+		this.deltaManager.off("readonly", this.onReadonly);
+	}
+
+	public submitSignal(content: any, targetClientId?: string): void {
+		return this.deltaManager.submitSignal(content, targetClientId);
+	}
+
+	public flush(): void {
+		return this.deltaManager.flush();
+	}
+
+	private readonly onPrepareSend = (messageBuffer: any[]): void => {
+		this.emit("prepareSend", messageBuffer);
+	};
+	private readonly onSubmitOp = (message: IDocumentMessage): void => {
+		this.emit("submitOp", message);
+	};
+	private readonly onOp = (message: ISequencedDocumentMessage, processingTime: number): void => {
+		this.emit("op", message, processingTime);
+	};
+	private readonly onPong = (latency: number): void => {
+		this.emit("pong", latency);
+	};
+	private readonly onConnect = (details: IConnectionDetails, opsBehind?: number): void => {
+		this.emit("connect", details, opsBehind);
+	};
+	private readonly onDisconnect = (reason: string, error?: IAnyDriverError): void => {
+		this.emit("disconnect", reason, error);
+	};
+	private readonly onReadonly = (
+		readonly: boolean,
+		readonlyConnectionReason?: { reason: string; error?: IErrorBase },
+	): void => {
+		this.emit("readonly", readonly, readonlyConnectionReason);
+	};
 }

package/src/gc/garbageCollection.ts

@@ -22,16 +22,16 @@ import {
 	PerformanceEvent,
 	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
-import { BlobManager } from "../blobManager";
+import { BlobManager } from "../blobManager.js";
 import {
 	InactiveResponseHeaderKey,
 	RuntimeHeaderData,
 	TombstoneResponseHeaderKey,
-} from "../containerRuntime";
-import { ClientSessionExpiredError } from "../error";
-import { ContainerMessageType, ContainerRuntimeGCMessage } from "../messageTypes";
-import { IRefreshSummaryResult } from "../summary";
-import { generateGCConfigs } from "./gcConfigs";
+} from "../containerRuntime.js";
+import { ClientSessionExpiredError } from "../error.js";
+import { ContainerMessageType, ContainerRuntimeGCMessage } from "../messageTypes.js";
+import { IRefreshSummaryResult } from "../summary/index.js";
+import { generateGCConfigs } from "./gcConfigs.js";
 import {
 	GCNodeType,
 	IGarbageCollector,
@@ -46,18 +46,22 @@ import {
 	ISweepPhaseStats,
 	GarbageCollectionMessage,
 	GarbageCollectionMessageType,
-} from "./gcDefinitions";
+	disableAutoRecoveryKey,
+} from "./gcDefinitions.js";
 import {
 	cloneGCData,
 	compatBehaviorAllowsGCMessageType,
 	concatGarbageCollectionData,
 	getGCDataFromSnapshot,
-} from "./gcHelpers";
-import { runGarbageCollection } from "./gcReferenceGraphAlgorithm";
-import { IGarbageCollectionSnapshotData, IGarbageCollectionState } from "./gcSummaryDefinitions";
-import { GCSummaryStateTracker } from "./gcSummaryStateTracker";
-import { UnreferencedStateTracker } from "./gcUnreferencedStateTracker";
-import { GCTelemetryTracker } from "./gcTelemetry";
+} from "./gcHelpers.js";
+import { runGarbageCollection } from "./gcReferenceGraphAlgorithm.js";
+import { IGarbageCollectionSnapshotData, IGarbageCollectionState } from "./gcSummaryDefinitions.js";
+import { GCSummaryStateTracker } from "./gcSummaryStateTracker.js";
+import {
+	UnreferencedStateTracker,
+	UnreferencedStateTrackerMap,
+} from "./gcUnreferencedStateTracker.js";
+import { GCTelemetryTracker } from "./gcTelemetry.js";
 
 /**
  * The garbage collector for the container runtime. It consolidates the garbage collection functionality and maintains
@@ -94,6 +98,7 @@ export class GarbageCollector implements IGarbageCollector {
 		return this.configs.shouldRunGC;
 	}
 
+	public readonly sessionExpiryTimerStarted: number | undefined;
 	// Keeps track of the GC state from the last run.
 	private gcDataFromLastRun: IGarbageCollectionData | undefined;
 	// Keeps a list of references (edges in the GC graph) between GC runs. Each entry has a node id and a list of
@@ -110,8 +115,15 @@ export class GarbageCollector implements IGarbageCollector {
 	private readonly initializeGCStateFromBaseSnapshotP: Promise<void>;
 	// The GC details generated from the base snapshot.
 	private readonly baseGCDetailsP: Promise<IGarbageCollectionDetailsBase>;
-	// Map of node ids to their unreferenced state tracker.
-	private readonly unreferencedNodesState: Map<string, UnreferencedStateTracker> = new Map();
+
+	/**
+	 * Map of node ids to their unreferenced state tracker
+	 * NOTE: The set of keys in this map is considered as the set of unreferenced nodes
+	 * as of the last GC run. So in between runs, nothing should be added or removed.
+	 */
+	private readonly unreferencedNodesState: UnreferencedStateTrackerMap =
+		new UnreferencedStateTrackerMap();
+
 	// The Timer responsible for closing the container when the session has expired
 	private sessionExpiryTimer: Timer | undefined;
 
@@ -164,6 +176,7 @@ export class GarbageCollector implements IGarbageCollector {
 
 		const baseSnapshot = createParams.baseSnapshot;
 		const readAndParseBlob = createParams.readAndParseBlob;
+		const pendingSessionExpiryTimerStarted = createParams.sessionExpiryTimerStarted;
 
 		this.mc = createChildMonitoringContext({
 			logger: createParams.baseLogger,
@@ -181,14 +194,26 @@ export class GarbageCollector implements IGarbageCollector {
 			const overrideSessionExpiryTimeoutMs = this.mc.config.getNumber(
 				"Fluid.GarbageCollection.TestOverride.SessionExpiryMs",
 			);
-			const timeoutMs = overrideSessionExpiryTimeoutMs ?? this.configs.sessionExpiryTimeoutMs;
+			let timeoutMs = this.configs.sessionExpiryTimeoutMs;
 
+			if (pendingSessionExpiryTimerStarted) {
+				// NOTE: This assumes the client clock hasn't been tampered with since the original session
+				const timeLapsedSincePendingTimer = Date.now() - pendingSessionExpiryTimerStarted;
+				timeoutMs -= timeLapsedSincePendingTimer;
+			}
+			timeoutMs = overrideSessionExpiryTimeoutMs ?? timeoutMs;
+			if (timeoutMs <= 0) {
+				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();
+			this.sessionExpiryTimerStarted = Date.now();
 		}
 
 		this.summaryStateTracker = new GCSummaryStateTracker(
@@ -443,7 +468,9 @@ export class GarbageCollector implements IGarbageCollector {
 	): Promise<IGCStats | undefined> {
 		const fullGC =
 			options.fullGC ??
-			(this.configs.runFullGC === true || this.summaryStateTracker.doesSummaryStateNeedReset);
+			(this.configs.runFullGC === true ||
+				this.summaryStateTracker.autoRecovery.fullGCRequested() ||
+				this.summaryStateTracker.doesSummaryStateNeedReset);
 
 		// Add the options that are used to run GC to the telemetry context.
 		telemetryContext?.setMultiple("fluid_GC", "Options", {
@@ -555,8 +582,9 @@ export class GarbageCollector implements IGarbageCollector {
 		);
 
 		// 4. Run the Sweep phase.
-		// It will tombstone any tombstone-ready nodes, and initiate the deletion of sweep-ready nodes by sending a
-		// sweep op. All clients, including this one, will delete these nodes once it processes the op.
+		// It will initiate the deletion (sending the GC Sweep op) of any sweep-ready nodes that are
+		// allowed to be deleted per config, and tombstone the rest along with the tombstone-ready nodes.
+		// Note that no nodes will be deleted until the GC Sweep op is processed.
 		this.runSweepPhase(gcResult, tombstoneReadyNodeIds, sweepReadyNodeIds);
 
 		this.gcDataFromLastRun = cloneGCData(gcData);
@@ -592,16 +620,10 @@ export class GarbageCollector implements IGarbageCollector {
 	): { tombstoneReadyNodeIds: Set<string>; sweepReadyNodeIds: Set<string> } {
 		// 1. Marks all referenced nodes by clearing their unreferenced tracker, if any.
 		for (const nodeId of allReferencedNodeIds) {
-			const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
-			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);
-			}
+			this.unreferencedNodesState.delete(nodeId);
 		}
 
-		// 2. Mark unreferenced nodes in this run by starting unreferenced tracking for them.
+		// 2. Mark unreferenced nodes in this run by starting or updating unreferenced tracking for them.
 		const tombstoneReadyNodeIds: Set<string> = new Set();
 		const sweepReadyNodeIds: Set<string> = new Set();
 		for (const nodeId of gcResult.deletedNodeIds) {
@@ -662,24 +684,39 @@ export class GarbageCollector implements IGarbageCollector {
 		 */
 
 		if (this.configs.testMode) {
-			// If we are running in GC test mode, unreferenced nodes (gcResult.deletedNodeIds) are deleted.
-			this.runtime.updateUnusedRoutes(gcResult.deletedNodeIds);
+			// If we are running in GC test mode, unreferenced nodes (gcResult.deletedNodeIds) are deleted immediately.
+			this.runtime.deleteSweepReadyNodes(gcResult.deletedNodeIds);
 			return;
 		}
 
-		// If sweep is disabled, we'll tombstone both tombstone-ready and sweep-ready nodes.
+		// We'll build up the lists of nodes to be either Tombstoned or Deleted
+		// based on the configuration and the nodes' current state.
+		// We must Tombstone any sweep-ready node that Sweep won't run for.
 		// This is important because a container may never load during a node's Sweep Grace Period,
 		// so that node would directly become sweep-ready skipping over tombstone-ready state,
 		// but should be Tombstoned since Sweep is disabled.
-		const { nodesToTombstone, nodesToDelete } = this.configs.shouldRunSweep
-			? {
-					nodesToTombstone: [...tombstoneReadyNodes],
-					nodesToDelete: [...sweepReadyNodes],
-			  }
-			: {
-					nodesToTombstone: [...tombstoneReadyNodes, ...sweepReadyNodes],
-					nodesToDelete: [],
-			  };
+		const { nodesToTombstone, nodesToDelete } = {
+			nodesToTombstone: [...tombstoneReadyNodes],
+			nodesToDelete: [] as string[],
+		};
+		switch (this.configs.shouldRunSweep) {
+			case "YES":
+				nodesToDelete.push(...sweepReadyNodes);
+				break;
+			case "ONLY_BLOBS":
+				sweepReadyNodes.forEach((nodeId) => {
+					const nodeType = this.runtime.getNodeType(nodeId);
+					if (nodeType === GCNodeType.Blob) {
+						nodesToDelete.push(nodeId);
+					} else {
+						nodesToTombstone.push(nodeId);
+					}
+				});
+				break;
+			default: // case "NO":
+				nodesToTombstone.push(...sweepReadyNodes);
+				break;
+		}
 
 		if (this.configs.tombstoneMode) {
 			this.tombstones = nodesToTombstone;
@@ -687,7 +724,7 @@ export class GarbageCollector implements IGarbageCollector {
 			this.runtime.updateTombstonedRoutes(this.tombstones);
 		}
 
-		if (this.configs.shouldRunSweep && nodesToDelete.length > 0) {
+		if (nodesToDelete.length > 0) {
 			// Do not send DDS node ids in the GC op. This is an optimization to reduce its size. Since GC applies to
 			// to data store only, all its DDSes are deleted along with it. The DDS ids will be retrieved from the
 			// local state when processing the op.
@@ -821,8 +858,7 @@ export class GarbageCollector implements IGarbageCollector {
 		}
 
 		return this.summaryStateTracker.summarize(
-			fullTree,
-			trackState,
+			trackState && !fullTree,
 			gcState,
 			this.deletedNodes,
 			this.tombstones,
@@ -856,21 +892,37 @@ export class GarbageCollector implements IGarbageCollector {
 	 * @param local - Whether it was send by this client.
 	 */
 	public processMessage(message: ContainerRuntimeGCMessage, local: boolean) {
-		switch (message.contents.type) {
-			case "Sweep": {
+		const gcMessageType = message.contents.type;
+		switch (gcMessageType) {
+			case GarbageCollectionMessageType.Sweep: {
 				// Delete the nodes whose ids are present in the contents.
 				this.deleteSweepReadyNodes(message.contents.deletedNodeIds);
 				break;
 			}
+			case GarbageCollectionMessageType.TombstoneLoaded: {
+				if (this.mc.config.getBoolean(disableAutoRecoveryKey) === true) {
+					break;
+				}
+
+				// Mark the node as referenced to ensure it isn't Swept
+				const tombstonedNodePath = message.contents.nodePath;
+				this.addedOutboundReference("/", tombstonedNodePath, true /* autorecovery */);
+
+				// In case the cause of the TombstoneLoaded event is incorrect GC Data (i.e. the object is actually reachable),
+				// do fullGC on the next run to get a chance to repair (in the likely case the bug is not deterministic)
+				this.summaryStateTracker.autoRecovery.requestFullGCOnNextRun();
+
+				break;
+			}
 			default: {
 				if (
 					!compatBehaviorAllowsGCMessageType(
-						message.contents.type,
+						gcMessageType,
 						message.compatDetails?.behavior,
 					)
 				) {
 					const error = DataProcessingError.create(
-						`Garbage collection message of unknown type ${message.contents.type}`,
+						`Garbage collection message of unknown type ${gcMessageType}`,
 						"processMessage",
 					);
 					throw error;
@@ -883,6 +935,10 @@ export class GarbageCollector implements IGarbageCollector {
 	/**
 	 * Delete nodes that are sweep-ready. Call the runtime to delete these nodes and clear the unreferenced state
 	 * tracking for nodes that are actually deleted by the runtime.
+	 *
+	 * Note that this doesn't check any configuration around whether Sweep is enabled.
+	 * That happens before the op is submitted, and from that point, any client should execute the delete.
+	 *
 	 * @param sweepReadyNodeIds - The ids of nodes that are ready to be deleted.
 	 */
 	private deleteSweepReadyNodes(sweepReadyNodeIds: readonly string[]) {
@@ -911,13 +967,9 @@ export class GarbageCollector implements IGarbageCollector {
 
 		// Clear unreferenced state tracking for deleted nodes.
 		for (const nodeId of deletedNodeIds) {
-			const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
-			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);
-			}
+			// Usually we avoid modifying the set of unreferencedNodesState keys in between GC runs,
+			// but this is ok since this node won't exist at all in the next GC run.
+			this.unreferencedNodesState.delete(nodeId);
 			this.deletedNodes.add(nodeId);
 		}
 	}
@@ -959,6 +1011,15 @@ export class GarbageCollector implements IGarbageCollector {
 			headers: headerData,
 		});
 
+		// Any time we log a Tombstone Loaded error (via Telemetry Tracker),
+		// we want to also trigger autorecovery to avoid the object being deleted
+		// Note: We don't need to trigger on "Changed" because any change will cause the object
+		// to be loaded by the Summarizer, and auto-recovery will be triggered then.
+		if (isTombstoned && reason === "Loaded") {
+			// Note that when a DataStore and its DDS are all loaded, each will trigger AutoRecovery for itself.
+			this.triggerAutoRecovery(nodePath);
+		}
+
 		const nodeType = this.runtime.getNodeType(nodePath);
 
 		// Unless this is a Loaded event for a Blob or DataStore, we're done after telemetry tracking
@@ -967,7 +1028,6 @@ export class GarbageCollector implements IGarbageCollector {
 		}
 
 		const errorRequest: IRequest = request ?? { url: nodePath };
-		// If the object is tombstoned and tombstone enforcement is configured, throw an error.
 		if (isTombstoned && this.throwOnTombstoneLoad && headerData?.allowTombstone !== true) {
 			// The requested data store is removed by gc. Create a 404 gc response exception.
 			throw responseToException(
@@ -995,14 +1055,42 @@ export class GarbageCollector implements IGarbageCollector {
 		}
 	}
 
+	/**
+	 * The given node should have its unreferenced state reset in the next GC,
+	 * even if the true GC graph shows it is unreferenced. This will
+	 * prevent it from being deleted by Sweep (after the Grace Period).
+	 *
+	 * Submit a GC op indicating that the Tombstone with the given path has been loaded.
+	 * Broadcasting this information in the op stream allows the Summarizer to reset unreferenced state
+	 * before runnint GC next.
+	 */
+	private triggerAutoRecovery(nodePath: string) {
+		if (this.mc.config.getBoolean(disableAutoRecoveryKey) === true) {
+			return;
+		}
+
+		// Use compat behavior "Ignore" since this is an optimization to opportunistically protect
+		// objects from deletion, so it's fine for older clients to ignore this op.
+		const containerGCMessage: ContainerRuntimeGCMessage = {
+			type: ContainerMessageType.GC,
+			contents: {
+				type: GarbageCollectionMessageType.TombstoneLoaded,
+				nodePath,
+			},
+			compatDetails: { behavior: "Ignore" },
+		};
+		this.submitMessage(containerGCMessage);
+	}
+
 	/**
 	 * Called when an outbound reference is added to a node. This is used to identify all nodes that have been
 	 * referenced between summaries so that their unreferenced timestamp can be reset.
 	 *
 	 * @param fromNodePath - The node from which the reference is added.
 	 * @param toNodePath - The node to which the reference is added.
+	 * @param autorecovery - This reference is added artificially, for autorecovery. Used for logging.
 	 */
-	public addedOutboundReference(fromNodePath: string, toNodePath: string) {
+	public addedOutboundReference(fromNodePath: string, toNodePath: string, autorecovery?: true) {
 		if (!this.configs.shouldRunGC) {
 			return;
 		}
@@ -1032,7 +1120,14 @@ export class GarbageCollector implements IGarbageCollector {
 			isTombstoned: this.tombstones.includes(toNodePath),
 			lastSummaryTime: this.getLastSummaryTimestampMs(),
 			fromId: fromNodePath,
+			autorecovery,
 		});
+
+		// This node is referenced - Clear its unreferenced state
+		// But don't delete the node id from the map yet.
+		// When generating GC stats, the set of nodes in here is used as the baseline for
+		// what was unreferenced in the last GC run.
+		this.unreferencedNodesState.get(toNodePath)?.stopTracking();
 	}
 
 	/**
@@ -1066,17 +1161,17 @@ export class GarbageCollector implements IGarbageCollector {
 			updatedAttachmentBlobCount: 0,
 		};
 
-		const updateNodeStats = (nodeId: string, referenced: boolean) => {
+		const updateNodeStats = (nodeId: string, isReferenced: boolean) => {
 			markPhaseStats.nodeCount++;
 			// If there is no previous GC data, every node's state is generated and is considered as updated.
 			// Otherwise, find out if any node went from referenced to unreferenced or vice-versa.
+			const wasNotReferenced = this.unreferencedNodesState.has(nodeId);
 			const stateUpdated =
-				this.gcDataFromLastRun === undefined ||
-				this.unreferencedNodesState.has(nodeId) === referenced;
+				this.gcDataFromLastRun === undefined || wasNotReferenced === isReferenced;
 			if (stateUpdated) {
 				markPhaseStats.updatedNodeCount++;
 			}
-			if (!referenced) {
+			if (!isReferenced) {
 				markPhaseStats.unrefNodeCount++;
 			}
 
@@ -1085,7 +1180,7 @@ export class GarbageCollector implements IGarbageCollector {
 				if (stateUpdated) {
 					markPhaseStats.updatedDataStoreCount++;
 				}
-				if (!referenced) {
+				if (!isReferenced) {
 					markPhaseStats.unrefDataStoreCount++;
 				}
 			}
@@ -1094,7 +1189,7 @@ export class GarbageCollector implements IGarbageCollector {
 				if (stateUpdated) {
 					markPhaseStats.updatedAttachmentBlobCount++;
 				}
-				if (!referenced) {
+				if (!isReferenced) {
 					markPhaseStats.unrefAttachmentBlobCount++;
 				}
 			}
@@ -1113,8 +1208,9 @@ export class GarbageCollector implements IGarbageCollector {
 
 	/**
 	 * Generates the stats of a garbage collection sweep phase run.
-	 * @param deletedNodes - The nodes that have been deleted until this run.
-	 * @param sweepReadyNodes - The nodes that are sweep-ready in this GC run.
+	 * @param deletedNodes - The nodes that have already been deleted even before this run.
+	 * @param sweepReadyNodes - The nodes that are sweep-ready in this GC run. These will be deleted but are not deleted yet,
+	 * due to either sweep not being enabled or the Sweep Op needing to roundtrip before the delete is executed.
 	 * @param markPhaseStats - The stats of the mark phase run.
 	 * @returns the stats of the sweep phase run.
 	 */
@@ -1160,19 +1256,18 @@ export class GarbageCollector implements IGarbageCollector {
 			}
 		}
 
-		// If sweep is enabled, the counts from the mark phase stats do not include nodes that have been
+		// The counts from the mark phase stats do not include nodes that were
 		// deleted in previous runs. So, add the deleted node counts to life time stats.
 		sweepPhaseStats.lifetimeNodeCount += sweepPhaseStats.deletedNodeCount;
 		sweepPhaseStats.lifetimeDataStoreCount += sweepPhaseStats.deletedDataStoreCount;
 		sweepPhaseStats.lifetimeAttachmentBlobCount += sweepPhaseStats.deletedAttachmentBlobCount;
 
-		if (this.configs.shouldRunSweep) {
-			return sweepPhaseStats;
-		}
-
-		// If sweep is not enabled, the current sweep-ready node stats should be added to deleted stats since this
-		// is the final state the node will be in.
-		// If sweep is enabled, this will happen in the run after the GC op round trips back.
+		// These stats are used to estimate the impact of GC in terms of how much garbage is/will be cleaned up.
+		// So we include the current sweep-ready node stats since these nodes will be deleted eventually.
+		// - If sweep is enabled, this will happen in the run after the GC op round trips back
+		//   (they'll be in deletedNodes that time).
+		// - If sweep is not enabled, we still want to include these nodes since they
+		//   _will be_ deleted once it is enabled.
 		for (const nodeId of sweepReadyNodes) {
 			sweepPhaseStats.deletedNodeCount++;
 			const nodeType = this.runtime.getNodeType(nodeId);
@@ -1182,6 +1277,7 @@ export class GarbageCollector implements IGarbageCollector {
 				sweepPhaseStats.deletedAttachmentBlobCount++;
 			}
 		}
+
 		return sweepPhaseStats;
 	}
 }