@fluidframework/container-runtime 2.0.0-rc.1.0.4 → 2.0.0-rc.2.0.0

package/src/dataStoreContexts.ts

@@ -6,7 +6,7 @@
 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";
 
 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", {
@@ -593,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) {
@@ -837,8 +858,7 @@ export class GarbageCollector implements IGarbageCollector {
 		}
 
 		return this.summaryStateTracker.summarize(
-			fullTree,
-			trackState,
+			trackState && !fullTree,
 			gcState,
 			this.deletedNodes,
 			this.tombstones,
@@ -872,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;
@@ -931,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);
 		}
 	}
@@ -979,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
@@ -987,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(
@@ -1015,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;
 		}
@@ -1052,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();
 	}
 
 	/**
@@ -1086,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++;
 			}
 
@@ -1105,7 +1180,7 @@ export class GarbageCollector implements IGarbageCollector {
 				if (stateUpdated) {
 					markPhaseStats.updatedDataStoreCount++;
 				}
-				if (!referenced) {
+				if (!isReferenced) {
 					markPhaseStats.unrefDataStoreCount++;
 				}
 			}
@@ -1114,7 +1189,7 @@ export class GarbageCollector implements IGarbageCollector {
 				if (stateUpdated) {
 					markPhaseStats.updatedAttachmentBlobCount++;
 				}
-				if (!referenced) {
+				if (!isReferenced) {
 					markPhaseStats.unrefAttachmentBlobCount++;
 				}
 			}

package/src/gc/gcConfigs.ts

@@ -8,7 +8,7 @@ import {
 	UsageError,
 	validatePrecondition,
 } from "@fluidframework/telemetry-utils";
-import { IContainerRuntimeMetadata } from "../summary";
+import { IContainerRuntimeMetadata } from "../summary/index.js";
 import {
 	nextGCVersion,
 	defaultInactiveTimeoutMs,
@@ -34,8 +34,8 @@ import {
 	IGCMetadata_Deprecated,
 	disableDatastoreSweepKey,
 	gcDisableDataStoreSweepOptionName,
-} from "./gcDefinitions";
-import { getGCVersion, shouldAllowGcSweep } from "./gcHelpers";
+} from "./gcDefinitions.js";
+import { getGCVersion, shouldAllowGcSweep } from "./gcHelpers.js";
 
 /**
  * Generates configurations for the Garbage Collector that it uses to determine what to run and how.

package/src/gc/gcDefinitions.ts

@@ -18,9 +18,9 @@ import {
 	IContainerRuntimeMetadata,
 	ICreateContainerMetadata,
 	IRefreshSummaryResult,
-} from "../summary";
-import { RuntimeHeaderData } from "../containerRuntime";
-import { ContainerRuntimeGCMessage } from "../messageTypes";
+} from "../summary/index.js";
+import { RuntimeHeaderData } from "../containerRuntime.js";
+import { ContainerRuntimeGCMessage } from "../messageTypes.js";
 
 /**
  * @alpha
@@ -80,6 +80,8 @@ export const gcVersionUpgradeToV4Key = "Fluid.GarbageCollection.GCVersionUpgrade
 export const disableDatastoreSweepKey = "Fluid.GarbageCollection.DisableDataStoreSweep";
 /** Config key to revert new paradigm of detecting outbound routes in ContainerRuntime layer (use true) */
 export const detectOutboundRoutesViaDDSKey = "Fluid.GarbageCollection.DetectOutboundRoutesViaDDS";
+/** Config key to disable auto-recovery mechanism that protects Tombstones that are loaded from being swept (use true) */
+export const disableAutoRecoveryKey = "Fluid.GarbageCollection.DisableAutoRecovery";
 
 // One day in milliseconds.
 export const oneDayMs = 1 * 24 * 60 * 60 * 1000;
@@ -257,6 +259,8 @@ export type GCNodeType = (typeof GCNodeType)[keyof typeof GCNodeType];
 export const GarbageCollectionMessageType = {
 	/** Message sent directing GC to delete the given nodes */
 	Sweep: "Sweep",
+	/** Message sent notifying GC that a Tombstoned object was Loaded */
+	TombstoneLoaded: "TombstoneLoaded",
 } as const;
 
 /**
@@ -270,16 +274,28 @@ export type GarbageCollectionMessageType =
  * @internal
  */
 export interface ISweepMessage {
-	type: "Sweep";
-	// The ids of nodes that are deleted.
+	/** @see GarbageCollectionMessageType.Sweep */
+	type: typeof GarbageCollectionMessageType.Sweep;
+	/** The ids of nodes that are deleted. */
 	deletedNodeIds: string[];
 }
 
+/**
+ * The GC TombstoneLoaded message.
+ * @internal
+ */
+export interface ITombstoneLoadedMessage {
+	/** @see GarbageCollectionMessageType.TombstoneLoaded */
+	type: typeof GarbageCollectionMessageType.TombstoneLoaded;
+	/** The id of Tombstoned node that was loaded. */
+	nodePath: string;
+}
+
 /**
  * Type for a message to be used for sending / received garbage collection messages.
  * @internal
  */
-export type GarbageCollectionMessage = ISweepMessage;
+export type GarbageCollectionMessage = ISweepMessage | ITombstoneLoadedMessage;
 
 /**
  * Defines the APIs for the runtime object to be passed to the garbage collector.
@@ -311,6 +327,12 @@ export interface IGarbageCollectionRuntime {
 
 /** Defines the contract for the garbage collector. */
 export interface IGarbageCollector {
+	/**
+	 * Tells the time at which session expiry timer started in a previous container.
+	 * This is only set when loading from a stashed container and will be equal to the
+	 * original container's local client time when it was loaded (and started the session expiry timer).
+	 */
+	readonly sessionExpiryTimerStarted: number | undefined;
 	/** Tells whether GC should run or not. */
 	readonly shouldRunGC: boolean;
 	/** Tells whether the GC state in summary needs to be reset in the next summary. */
@@ -359,7 +381,7 @@ export interface IGarbageCollector {
 		headerData?: RuntimeHeaderData,
 	): void;
 	/** Called when a reference is added to a node. Used to identify nodes that were referenced between summaries. */
-	addedOutboundReference(fromNodePath: string, toNodePath: string): void;
+	addedOutboundReference(fromNodePath: string, toNodePath: string, autorecovery?: true): void;
 	/** Called to process a garbage collection message. */
 	processMessage(message: ContainerRuntimeGCMessage, local: boolean): void;
 	/** Returns true if this node has been deleted by GC during sweep phase. */
@@ -382,6 +404,7 @@ export interface IGarbageCollectorCreateParams {
 	readonly getLastSummaryTimestampMs: () => number | undefined;
 	readonly readAndParseBlob: ReadAndParseBlob;
 	readonly submitMessage: (message: ContainerRuntimeGCMessage) => void;
+	readonly sessionExpiryTimerStarted?: number | undefined;
 }
 
 /**

package/src/gc/gcHelpers.ts

@@ -12,12 +12,12 @@ import {
 	IGarbageCollectionData,
 	IGarbageCollectionDetailsBase,
 } from "@fluidframework/runtime-definitions";
-import { GCFeatureMatrix, GCVersion, IGCMetadata } from "./gcDefinitions";
+import { GCFeatureMatrix, GCVersion, IGCMetadata } from "./gcDefinitions.js";
 import {
 	IGarbageCollectionNodeData,
 	IGarbageCollectionSnapshotData,
 	IGarbageCollectionState,
-} from "./gcSummaryDefinitions";
+} from "./gcSummaryDefinitions.js";
 
 export function getGCVersion(metadata?: IGCMetadata): GCVersion {
 	if (!metadata) {

package/src/gc/gcReferenceGraphAlgorithm.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { IGCResult } from "./gcDefinitions";
+import { IGCResult } from "./gcDefinitions.js";
 
 /**
  * Runs garbage collection on the given reference graph.