@fluidframework/container-runtime 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

package/src/dataStore.ts

@@ -3,15 +3,17 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLoggerExt, TelemetryDataTag, UsageError } from "@fluidframework/telemetry-utils";
-import { assert, unreachableCase } from "@fluidframework/core-utils";
 import { AttachState } from "@fluidframework/container-definitions";
 import { FluidObject, IFluidHandle } from "@fluidframework/core-interfaces";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import {
 	AliasResult,
 	IDataStore,
 	IFluidDataStoreChannel,
-} from "@fluidframework/runtime-definitions";
+} from "@fluidframework/runtime-definitions/internal";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { TelemetryDataTag, UsageError } from "@fluidframework/telemetry-utils/internal";
+
 import { ChannelCollection } from "./channelCollection.js";
 import { ContainerMessageType } from "./messageTypes.js";
 
@@ -115,7 +117,10 @@ class DataStore implements IDataStore {
 		this.fluidDataStoreChannel.makeVisibleAndAttachGraph();
 
 		if (this.parentContext.attachState === AttachState.Detached) {
-			const localResult = this.channelCollection.processAliasMessageCore(message);
+			const localResult = this.channelCollection.processAliasMessageCore(
+				this.internalId,
+				alias,
+			);
 			// Explicitly lock-out future attempts of aliasing,
 			// regardless of result
 			this.aliasState = AliasState.Aliased;

package/src/dataStoreContext.ts

@@ -3,19 +3,20 @@
  * Licensed under the MIT License.
  */
 
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { AttachState, IAudience, IDeltaManager } from "@fluidframework/container-definitions";
 import {
-	IDisposable,
 	FluidObject,
+	IDisposable,
+	IEvent,
+	IFluidHandle,
 	IRequest,
 	IResponse,
-	IFluidHandle,
 	ITelemetryBaseProperties,
 } from "@fluidframework/core-interfaces";
-import { IAudience, IDeltaManager, AttachState } from "@fluidframework/container-definitions";
-import { TypedEventEmitter } from "@fluid-internal/client-utils";
-import { assert, LazyPromise } from "@fluidframework/core-utils";
-import { IDocumentStorageService } from "@fluidframework/driver-definitions";
-import { BlobTreeEntry, readAndParse } from "@fluidframework/driver-utils";
+import { assert, LazyPromise, unreachableCase } from "@fluidframework/core-utils/internal";
+import { IDocumentStorageService } from "@fluidframework/driver-definitions/internal";
+import { BlobTreeEntry, readAndParse } from "@fluidframework/driver-utils/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 import {
 	IClientDetails,
@@ -26,53 +27,55 @@ import {
 	ITreeEntry,
 } from "@fluidframework/protocol-definitions";
 import {
-	channelsTreeName,
+	IGarbageCollectionData,
+	IInboundSignalMessage,
+	ISummaryTreeWithStats,
+	ITelemetryContext,
+} from "@fluidframework/runtime-definitions";
+import {
 	CreateChildSummarizerNodeFn,
 	CreateChildSummarizerNodeParam,
 	FluidDataStoreRegistryEntry,
+	IContainerRuntimeBase,
+	IDataStore,
 	IFluidDataStoreChannel,
 	IFluidDataStoreContext,
-	IFluidParentContext,
-	IContainerRuntimeBase,
 	IFluidDataStoreContextDetached,
-	IFluidDataStoreContextEvents,
 	IFluidDataStoreRegistry,
-	IGarbageCollectionData,
+	IFluidParentContext,
 	IGarbageCollectionDetailsBase,
-	IInboundSignalMessage,
 	IProvideFluidDataStoreFactory,
 	ISummarizeInternalResult,
 	ISummarizeResult,
 	ISummarizerNodeWithGC,
 	SummarizeInternalFn,
-	ITelemetryContext,
-	ISummaryTreeWithStats,
-	IDataStore,
+	channelsTreeName,
 	gcDataBlobKey,
-} from "@fluidframework/runtime-definitions";
-import { addBlobToSummary } from "@fluidframework/runtime-utils";
+} from "@fluidframework/runtime-definitions/internal";
+import { addBlobToSummary } from "@fluidframework/runtime-utils/internal";
 import {
-	createChildMonitoringContext,
 	DataCorruptionError,
 	DataProcessingError,
-	extractSafePropertiesFromMessage,
-	generateStack,
 	LoggingError,
 	MonitoringContext,
-	tagCodeArtifacts,
 	ThresholdCounter,
-} from "@fluidframework/telemetry-utils";
+	createChildMonitoringContext,
+	extractSafePropertiesFromMessage,
+	generateStack,
+	tagCodeArtifacts,
+} from "@fluidframework/telemetry-utils/internal";
+
+import { detectOutboundRoutesViaDDSKey, sendGCUnexpectedUsageEvent } from "./gc/index.js";
 import {
-	dataStoreAttributesBlobName,
-	hasIsolatedChannels,
-	wrapSummaryInChannelsTree,
 	ReadFluidDataStoreAttributes,
 	WriteFluidDataStoreAttributes,
+	dataStoreAttributesBlobName,
 	getAttributesFormatVersion,
 	getFluidDataStoreAttributes,
+	hasIsolatedChannels,
 	summarizerClientType,
+	wrapSummaryInChannelsTree,
 } from "./summary/index.js";
-import { detectOutboundRoutesViaDDSKey, sendGCUnexpectedUsageEvent } from "./gc/index.js";
 
 function createAttributes(
 	pkg: readonly string[],
@@ -90,14 +93,40 @@ export function createAttributesBlob(pkg: readonly string[], isRootDataStore: bo
 	return new BlobTreeEntry(dataStoreAttributesBlobName, JSON.stringify(attributes));
 }
 
-interface ISnapshotDetails {
+/** @internal */
+export interface ISnapshotDetails {
 	pkg: readonly string[];
 	isRootDataStore: boolean;
 	snapshot?: ISnapshotTree;
 	sequenceNumber?: number;
 }
 
-/** Properties necessary for creating a FluidDataStoreContext */
+/**
+ * This is interface that every context should implement.
+ * This interface is used for context's parent - ChannelCollection.
+ * It should not be exposed to any other users of context.
+ * @internal
+ */
+export interface IFluidDataStoreContextInternal extends IFluidDataStoreContext {
+	getAttachData(
+		includeGCData: boolean,
+		telemetryContext?: ITelemetryContext,
+	): {
+		attachSummary: ISummaryTreeWithStats;
+		type: string;
+	};
+
+	getInitialSnapshotDetails(): Promise<ISnapshotDetails>;
+
+	realize(): Promise<IFluidDataStoreChannel>;
+
+	isRoot(): Promise<boolean>;
+}
+
+/**
+ * Properties necessary for creating a FluidDataStoreContext
+ * @internal
+ */
 export interface IFluidDataStoreContextProps {
 	readonly id: string;
 	readonly parentContext: IFluidParentContext;
@@ -108,11 +137,13 @@ export interface IFluidDataStoreContextProps {
 	readonly loadingGroupId?: string;
 }
 
-/** Properties necessary for creating a local FluidDataStoreContext */
+/**
+ * Properties necessary for creating a local FluidDataStoreContext
+ * @internal
+ */
 export interface ILocalFluidDataStoreContextProps extends IFluidDataStoreContextProps {
 	readonly pkg: Readonly<string[]> | undefined;
 	readonly snapshotTree: ISnapshotTree | undefined;
-	readonly isRootDataStore: boolean | undefined;
 	readonly makeLocallyVisibleFn: () => void;
 	/**
 	 * @deprecated 0.16 Issue #1635, #3631
@@ -120,22 +151,36 @@ export interface ILocalFluidDataStoreContextProps extends IFluidDataStoreContext
 	readonly createProps?: any;
 }
 
-/** Properties necessary for creating a local FluidDataStoreContext */
+/**
+ * Properties necessary for creating a local FluidDataStoreContext
+ * @internal
+ */
 export interface ILocalDetachedFluidDataStoreContextProps extends ILocalFluidDataStoreContextProps {
 	readonly channelToDataStoreFn: (channel: IFluidDataStoreChannel) => IDataStore;
 }
 
-/** Properties necessary for creating a remote FluidDataStoreContext */
+/**
+ * Properties necessary for creating a remote FluidDataStoreContext
+ * @internal
+ */
 export interface IRemoteFluidDataStoreContextProps extends IFluidDataStoreContextProps {
 	readonly snapshotTree: ISnapshotTree | undefined;
 }
 
+// back-compat: To be removed in the future.
+// Added in "2.0.0-rc.2.0.0" timeframe (to support older builds).
+/** @internal */
+export interface IFluidDataStoreContextEvents extends IEvent {
+	(event: "attaching" | "attached", listener: () => void);
+}
+
 /**
  * Represents the context for the store. This context is passed to the store runtime.
+ * @internal
  */
 export abstract class FluidDataStoreContext
 	extends TypedEventEmitter<IFluidDataStoreContextEvents>
-	implements IFluidDataStoreContext, IFluidParentContext, IDisposable
+	implements IFluidDataStoreContextInternal, IFluidParentContext, IDisposable
 {
 	public get packagePath(): readonly string[] {
 		assert(this.pkg !== undefined, 0x139 /* "Undefined package path" */);
@@ -208,17 +253,13 @@ export abstract class FluidDataStoreContext
 	public readonly gcTombstoneEnforcementAllowed: boolean;
 
 	/** If true, this means that this data store context and its children have been removed from the runtime */
-	private deleted: boolean = false;
+	protected deleted: boolean = false;
 
 	public get attachState(): AttachState {
 		return this._attachState;
 	}
 
 	public get IFluidDataStoreRegistry(): IFluidDataStoreRegistry | undefined {
-		assert(
-			this.channel !== undefined,
-			0x8f3 /* This should be called after the channel is created, when the registry is populated */,
-		);
 		return this.registry;
 	}
 
@@ -230,8 +271,20 @@ export abstract class FluidDataStoreContext
 	 * 2. is root as part of the base snapshot that the datastore loaded from
 	 * @returns whether a datastore is root
 	 */
-	public async isRoot(): Promise<boolean> {
-		return this.isInMemoryRoot() || (await this.getInitialSnapshotDetails()).isRootDataStore;
+	public async isRoot(aliasedDataStores?: Set<string>): Promise<boolean> {
+		if (this.isInMemoryRoot()) {
+			return true;
+		}
+
+		// This if is a performance optimization.
+		// We know that if the base snapshot is omitted, then the isRootDataStore flag is not set.
+		// That means we can skip the expensive call to getInitialSnapshotDetails for virtualized datastores,
+		// and get the information from the alias map directly.
+		if (aliasedDataStores !== undefined && this.baseSnapshot?.omitted === true) {
+			return aliasedDataStores.has(this.id);
+		}
+
+		return (await this.getInitialSnapshotDetails()).isRootDataStore;
 	}
 
 	/**
@@ -375,6 +428,8 @@ export abstract class FluidDataStoreContext
 		this._tombstoned = tombstone;
 	}
 
+	public abstract setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
+
 	private rejectDeferredRealize(
 		reason: string,
 		failedPkgPath?: string,
@@ -759,10 +814,10 @@ export abstract class FluidDataStoreContext
 	/**
 	 * Submits the signal to be sent to other clients.
 	 * @param type - Type of the signal.
-	 * @param content - Content of the signal.
+	 * @param content - Content of the signal. Should be a JSON serializable object or primitive.
 	 * @param targetClientId - When specified, the signal is only sent to the provided client id.
 	 */
-	public submitSignal(type: string, content: any, targetClientId?: string) {
+	public submitSignal(type: string, content: unknown, targetClientId?: string) {
 		this.verifyNotClosed("submitSignal");
 
 		assert(!!this.channel, 0x147 /* "Channel must exist on submitting signal" */);
@@ -778,6 +833,48 @@ export abstract class FluidDataStoreContext
 		this.makeLocallyVisibleFn();
 	}
 
+	protected processPendingOps(channel: IFluidDataStoreChannel) {
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		const pending = this.pending!;
+
+		// Apply all pending ops
+		for (const op of pending) {
+			// Only process ops whose seq number is greater than snapshot sequence number from which it loaded.
+			const seqNumber = this.baseSnapshotSequenceNumber ?? -1;
+			if (op.sequenceNumber > seqNumber) {
+				channel.process(op, false, undefined /* localOpMetadata */);
+			}
+		}
+		this.pending = undefined;
+
+		this.thresholdOpsCounter.send("ProcessPendingOps", pending.length);
+	}
+
+	protected completeBindingRuntime(channel: IFluidDataStoreChannel) {
+		// And now mark the runtime active
+		this.loaded = true;
+		this.channel = channel;
+
+		// Channel does not know when it's "live" (as in - starts to receive events in the system)
+		// It may read current state of the system when channel was created, but it was not getting any updates
+		// through creation process and could have missed events. So update it on current state.
+		// Once this.loaded is set (above), it will stat receiving events.
+		channel.setConnectionState(this.connected, this.clientId);
+
+		// Freeze the package path to ensure that someone doesn't modify it when it is
+		// returned in packagePath().
+		Object.freeze(this.pkg);
+
+		/**
+		 * Update the used routes of the channel. If GC has run before this data store was realized, we will have
+		 * the used routes saved. So, this will ensure that all the child contexts have up-to-date used routes as
+		 * per the last time GC was run.
+		 * Also, this data store may have been realized during summarize. In that case, the child contexts need to
+		 * have their used routes updated to determine if its needs to summarize again and to add it to the summary.
+		 */
+		this.updateChannelUsedRoutes();
+	}
+
 	protected async bindRuntime(channel: IFluidDataStoreChannel, existing: boolean) {
 		if (this.channel) {
 			throw new Error("Runtime already bound");
@@ -789,23 +886,7 @@ export abstract class FluidDataStoreContext
 		);
 		assert(this.pkg !== undefined, 0x14a /* "Undefined package path" */);
 
-		if (existing) {
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			const pending = this.pending!;
-
-			// Apply all pending ops
-			for (const op of pending) {
-				// Only process ops whose seq number is greater than snapshot sequence number from which it loaded.
-				const seqNumber = this.baseSnapshotSequenceNumber ?? -1;
-				if (op.sequenceNumber > seqNumber) {
-					channel.process(op, false, undefined /* localOpMetadata */);
-				}
-			}
-
-			this.thresholdOpsCounter.send("ProcessPendingOps", pending.length);
-		} else {
-			assert(this.pending?.length === 0, 0x8f4 /* no pending ops */);
-
+		if (!existing) {
 			// Execute data store's entry point to make sure that for a local (aka detached from container) data store, the
 			// entryPoint initialization function is called before the data store gets attached and potentially connected to
 			// the delta stream, so it gets a chance to do things while the data store is still "purely local".
@@ -815,24 +896,9 @@ export abstract class FluidDataStoreContext
 			// before the data store is attached.
 			await channel.entryPoint.get();
 		}
-		this.pending = undefined;
-
-		// And now mark the runtime active
-		this.loaded = true;
-		this.channel = channel;
-
-		// Freeze the package path to ensure that someone doesn't modify it when it is
-		// returned in packagePath().
-		Object.freeze(this.pkg);
 
-		/**
-		 * Update the used routes of the channel. If GC has run before this data store was realized, we will have
-		 * the used routes saved. So, this will ensure that all the child contexts have up-to-date used routes as
-		 * per the last time GC was run.
-		 * Also, this data store may have been realized during summarize. In that case, the child contexts need to
-		 * have their used routes updated to determine if its needs to summarize again and to add it to the summary.
-		 */
-		this.updateChannelUsedRoutes();
+		this.processPendingOps(channel);
+		this.completeBindingRuntime(channel);
 	}
 
 	public async getAbsoluteUrl(relativeUrl: string): Promise<string | undefined> {
@@ -992,6 +1058,7 @@ export abstract class FluidDataStoreContext
 	}
 }
 
+/** @internal */
 export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
 	// Tells whether we need to fetch the snapshot before use. This is to support Data Virtualization.
 	private snapshotFetchRequired: boolean;
@@ -1010,6 +1077,18 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
 		}
 	}
 
+	/* 
+	This API should not be called for RemoteFluidDataStoreContext. But here is one scenario where it's not the case:
+	The scenario (hit by stashedOps.spec.ts, "resends attach op" UT is the following (as far as I understand):
+	1. data store is being attached in attached container
+	2. container state is serialized (stashed ops feature)
+	3. new container instance is rehydrated (from stashed ops)
+	    - As result, we create RemoteFluidDataStoreContext for this data store that is actually in "attaching" state (as of # 2).
+		  But its state is set to attached when loading container from stashed ops
+	4. attach op for this data store is processed - setAttachState() is called.
+	*/
+	public setAttachState(attachState: AttachState.Attaching | AttachState.Attached) {}
+
 	private readonly initialSnapshotDetailsP = new LazyPromise<ISnapshotDetails>(async () => {
 		// Sequence number of the snapshot.
 		let sequenceNumber: number | undefined;
@@ -1092,6 +1171,7 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
 
 /**
  * Base class for detached & attached context classes
+ * @internal
  */
 export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
 	private readonly snapshotTree: ISnapshotTree | undefined;
@@ -1103,7 +1183,7 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
 	constructor(props: ILocalFluidDataStoreContextProps) {
 		super(
 			props,
-			props.snapshotTree !== undefined ? true : false /* existing */,
+			props.snapshotTree !== undefined /* existing */,
 			true /* isLocalDataStore */,
 			props.makeLocallyVisibleFn,
 		);
@@ -1112,29 +1192,50 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
 		this.identifyLocalChangeInSummarizer("DataStoreCreatedInSummarizer");
 
 		this.snapshotTree = props.snapshotTree;
-		if (props.isRootDataStore === true) {
-			this.setInMemoryRoot();
-		}
 		this.createProps = props.createProps;
-		this.attachListeners();
 	}
 
-	private attachListeners(): void {
-		if (this.attachState !== AttachState.Attached) {
-			this.once("attaching", () => {
+	public setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void {
+		switch (attachState) {
+			case AttachState.Attaching:
 				assert(
 					this.attachState === AttachState.Detached,
 					0x14d /* "Should move from detached to attaching" */,
 				);
 				this._attachState = AttachState.Attaching;
-			});
-			this.once("attached", () => {
-				assert(
-					this.attachState === AttachState.Attaching,
-					0x14e /* "Should move from attaching to attached" */,
-				);
-				this._attachState = AttachState.Attached;
-			});
+				if (this.channel?.setAttachState) {
+					this.channel.setAttachState(attachState);
+				} else if (this.channel) {
+					// back-compat! To be removed in the future
+					// Added in "2.0.0-rc.2.0.0" timeframe.
+					this.emit("attaching");
+				}
+				break;
+			case AttachState.Attached:
+				// We can get called into here twice, as result of both container and data store being attached, if
+				// those processes overlapped, for example, in a flow like that one:
+				// 1. Container attach started
+				// 2. data store attachment started
+				// 3. container attached
+				// 4. data store attached.
+				if (this.attachState !== AttachState.Attached) {
+					assert(
+						this.attachState === AttachState.Attaching,
+						0x14e /* "Should move from attaching to attached" */,
+					);
+					this._attachState = AttachState.Attached;
+					this.channel?.setAttachState?.(attachState);
+					if (this.channel?.setAttachState) {
+						this.channel.setAttachState(attachState);
+					} else if (this.channel) {
+						// back-compat! To be removed in the future
+						// Added in "2.0.0-rc.2.0.0" timeframe.
+						this.emit("attached");
+					}
+				}
+				break;
+			default:
+				unreachableCase(attachState, "unreached");
 		}
 	}
 
@@ -1250,6 +1351,7 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
  * Various workflows (snapshot creation, requests) result in .realize() being called
  * on context, resulting in instantiation and attachment of runtime.
  * Runtime is created using data store factory that is associated with this context.
+ * @internal
  */
 export class LocalFluidDataStoreContext extends LocalFluidDataStoreContextBase {
 	constructor(props: ILocalFluidDataStoreContextProps) {

package/src/dataStoreContexts.ts

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

package/src/dataStoreRegistry.ts

@@ -2,12 +2,13 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { UsageError } from "@fluidframework/telemetry-utils";
+
 import {
 	FluidDataStoreRegistryEntry,
 	IFluidDataStoreRegistry,
 	NamedFluidDataStoreRegistryEntries,
-} from "@fluidframework/runtime-definitions";
+} from "@fluidframework/runtime-definitions/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 /**
  * @internal

package/src/deltaManagerSummarizerProxy.ts

@@ -139,7 +139,7 @@ export class DeltaManagerSummarizerProxy
 		this.deltaManager.off("readonly", this.onReadonly);
 	}
 
-	public submitSignal(content: any, targetClientId?: string): void {
+	public submitSignal(content: string, targetClientId?: string): void {
 		return this.deltaManager.submitSignal(content, targetClientId);
 	}
 

package/src/deltaScheduler.ts

@@ -3,10 +3,11 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLoggerExt, formatTick } from "@fluidframework/telemetry-utils";
 import { performance } from "@fluid-internal/client-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
 import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { formatTick } from "@fluidframework/telemetry-utils/internal";
 
 /**
  * DeltaScheduler is responsible for the scheduling of inbound delta queue in cases where there

package/src/error.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { ContainerErrorTypes } from "@fluidframework/container-definitions";
-import { IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils";
+import { ContainerErrorTypes } from "@fluidframework/container-definitions/internal";
+import { IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils/internal";
 
 /**
  * Error indicating that a client's session has reached its time limit and is closed.

package/src/gc/garbageCollection.ts

@@ -3,25 +3,25 @@
  * Licensed under the MIT License.
  */
 
-import { assert, LazyPromise, Timer } from "@fluidframework/core-utils";
 import { IRequest } from "@fluidframework/core-interfaces";
+import { assert, LazyPromise, Timer } from "@fluidframework/core-utils/internal";
+import { IGarbageCollectionData, ITelemetryContext } from "@fluidframework/runtime-definitions";
 import {
-	gcTreeKey,
-	IGarbageCollectionData,
 	IGarbageCollectionDetailsBase,
 	ISummarizeResult,
-	ITelemetryContext,
-} from "@fluidframework/runtime-definitions";
-import { createResponseError, responseToException } from "@fluidframework/runtime-utils";
+	gcTreeKey,
+} from "@fluidframework/runtime-definitions/internal";
+import { createResponseError, responseToException } from "@fluidframework/runtime-utils/internal";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import {
-	createChildLogger,
-	createChildMonitoringContext,
 	DataProcessingError,
-	ITelemetryLoggerExt,
 	MonitoringContext,
 	PerformanceEvent,
+	createChildLogger,
+	createChildMonitoringContext,
 	tagCodeArtifacts,
-} from "@fluidframework/telemetry-utils";
+} from "@fluidframework/telemetry-utils/internal";
+
 import { BlobManager } from "../blobManager.js";
 import {
 	InactiveResponseHeaderKey,
@@ -31,21 +31,22 @@ import {
 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,
-	IGarbageCollectorCreateParams,
-	IGarbageCollectionRuntime,
+	GarbageCollectionMessage,
+	GarbageCollectionMessageType,
+	IGCMetadata,
 	IGCResult,
 	IGCStats,
-	UnreferencedState,
-	IGCMetadata,
+	IGarbageCollectionRuntime,
+	IGarbageCollector,
 	IGarbageCollectorConfigs,
+	IGarbageCollectorCreateParams,
 	IMarkPhaseStats,
 	ISweepPhaseStats,
-	GarbageCollectionMessage,
-	GarbageCollectionMessageType,
+	UnreferencedState,
 	disableAutoRecoveryKey,
 } from "./gcDefinitions.js";
 import {
@@ -57,11 +58,11 @@ import {
 import { runGarbageCollection } from "./gcReferenceGraphAlgorithm.js";
 import { IGarbageCollectionSnapshotData, IGarbageCollectionState } from "./gcSummaryDefinitions.js";
 import { GCSummaryStateTracker } from "./gcSummaryStateTracker.js";
+import { GCTelemetryTracker } from "./gcTelemetry.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
@@ -684,8 +685,8 @@ 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;
 		}