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

package/src/channelCollection.ts

@@ -3,90 +3,95 @@
  * Licensed under the MIT License.
  */
 
+import { AttachState } from "@fluidframework/container-definitions";
 import {
-	ITelemetryBaseLogger,
+	FluidObject,
 	IDisposable,
 	IFluidHandle,
 	IRequest,
-	FluidObject,
 	IResponse,
+	ITelemetryBaseLogger,
 } from "@fluidframework/core-interfaces";
-import { FluidObjectHandle } from "@fluidframework/datastore";
+import { assert, Lazy, LazyPromise } from "@fluidframework/core-utils/internal";
+import { FluidObjectHandle } from "@fluidframework/datastore/internal";
+import { buildSnapshotTree } from "@fluidframework/driver-utils/internal";
 import { ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
+import {
+	IGarbageCollectionData,
+	IInboundSignalMessage,
+	ISummaryTreeWithStats,
+	ITelemetryContext,
+} from "@fluidframework/runtime-definitions";
 import {
 	AliasResult,
-	channelsTreeName,
 	CreateSummarizerNodeSource,
 	IAttachMessage,
 	IEnvelope,
 	IFluidDataStoreChannel,
+	IFluidDataStoreContext,
 	IFluidDataStoreContextDetached,
-	IGarbageCollectionData,
-	IInboundSignalMessage,
+	IFluidDataStoreFactory,
+	IFluidDataStoreRegistry,
 	IFluidParentContext,
-	InboundAttachMessage,
 	ISummarizeResult,
-	ISummaryTreeWithStats,
-	ITelemetryContext,
-	IFluidDataStoreFactory,
-	IFluidDataStoreContext,
+	InboundAttachMessage,
 	NamedFluidDataStoreRegistryEntries,
-	IFluidDataStoreRegistry,
-} from "@fluidframework/runtime-definitions";
+	channelsTreeName,
+} from "@fluidframework/runtime-definitions/internal";
 import {
+	GCDataBuilder,
+	RequestParser,
+	SummaryTreeBuilder,
 	convertSnapshotTreeToSummaryTree,
 	convertSummaryTreeToITree,
 	create404Response,
 	createResponseError,
-	GCDataBuilder,
+	encodeCompactIdToString,
 	isSerializedHandle,
 	processAttachMessageGCData,
 	responseToException,
-	SummaryTreeBuilder,
 	unpackChildNodesUsedRoutes,
-	RequestParser,
-	encodeCompactIdToString,
-} from "@fluidframework/runtime-utils";
+} from "@fluidframework/runtime-utils/internal";
 import {
-	createChildMonitoringContext,
 	DataCorruptionError,
 	DataProcessingError,
-	extractSafePropertiesFromMessage,
 	LoggingError,
 	MonitoringContext,
-	tagCodeArtifacts,
 	createChildLogger,
-} from "@fluidframework/telemetry-utils";
-import { AttachState } from "@fluidframework/container-definitions";
-import { buildSnapshotTree } from "@fluidframework/driver-utils";
-import { assert, Lazy, LazyPromise } from "@fluidframework/core-utils";
-import { DataStoreContexts } from "./dataStoreContexts.js";
-import { defaultRuntimeHeaderData, RuntimeHeaderData } from "./containerRuntime.js";
-import {
-	FluidDataStoreContext,
-	RemoteFluidDataStoreContext,
-	LocalFluidDataStoreContext,
-	createAttributesBlob,
-	LocalDetachedFluidDataStoreContext,
-} from "./dataStoreContext.js";
-import { StorageServiceWithAttachBlobs } from "./storageServiceWithAttachBlobs.js";
+	createChildMonitoringContext,
+	extractSafePropertiesFromMessage,
+	tagCodeArtifacts,
+} from "@fluidframework/telemetry-utils/internal";
+
+import { RuntimeHeaderData, defaultRuntimeHeaderData } from "./containerRuntime.js";
 import {
 	IDataStoreAliasMessage,
 	channelToDataStore,
 	isDataStoreAliasMessage,
 } from "./dataStore.js";
+import {
+	FluidDataStoreContext,
+	IFluidDataStoreContextInternal,
+	ILocalDetachedFluidDataStoreContextProps,
+	LocalDetachedFluidDataStoreContext,
+	LocalFluidDataStoreContext,
+	RemoteFluidDataStoreContext,
+	createAttributesBlob,
+} from "./dataStoreContext.js";
+import { DataStoreContexts } from "./dataStoreContexts.js";
+import { FluidDataStoreRegistry } from "./dataStoreRegistry.js";
 import {
 	GCNodeType,
 	detectOutboundRoutesViaDDSKey,
 	trimLeadingAndTrailingSlashes,
 } from "./gc/index.js";
+import { ContainerMessageType, LocalContainerRuntimeMessage } from "./messageTypes.js";
+import { StorageServiceWithAttachBlobs } from "./storageServiceWithAttachBlobs.js";
 import {
 	IContainerRuntimeMetadata,
 	nonDataStorePaths,
 	rootHasIsolatedChannels,
 } from "./summary/index.js";
-import { ContainerMessageType, LocalContainerRuntimeMessage } from "./messageTypes.js";
-import { FluidDataStoreRegistry } from "./dataStoreRegistry.js";
 
 /**
  * Accepted header keys for requests coming to the runtime.
@@ -180,7 +185,10 @@ export function wrapContext(context: IFluidParentContext): IFluidParentContext {
 			return context.getCreateChildSummarizerNodeFn?.(...args);
 		},
 		deleteChildSummarizerNode: (...args) => {
-			return context.deleteChildSummarizerNode?.(...args);
+			return context.deleteChildSummarizerNode(...args);
+		},
+		setChannelDirty: (address: string) => {
+			return context.setChannelDirty(address);
 		},
 	};
 }
@@ -215,7 +223,7 @@ export function wrapContextForInnerChannel(
 		);
 	};
 
-	context.submitSignal = (type: string, contents: any, targetClientId?: string) => {
+	context.submitSignal = (type: string, contents: unknown, targetClientId?: string) => {
 		const envelope: IEnvelope = {
 			address: id,
 			contents,
@@ -237,7 +245,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	// 0.24 back-compat attachingBeforeSummary
 	public readonly attachOpFiredForDataStore = new Set<string>();
 
-	private readonly mc: MonitoringContext;
+	protected readonly mc: MonitoringContext;
 
 	private readonly disposeOnce = new Lazy<void>(() => this.contexts.dispose());
 
@@ -261,10 +269,11 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		Promise<AliasResult>
 	>();
 
-	private readonly contexts: DataStoreContexts;
+	protected readonly contexts: DataStoreContexts;
+	private readonly aliasedDataStores: Set<string>;
 
 	constructor(
-		private readonly baseSnapshot: ISnapshotTree | undefined,
+		protected readonly baseSnapshot: ISnapshotTree | undefined,
 		public readonly parentContext: IFluidParentContext,
 		baseLogger: ITelemetryBaseLogger,
 		private readonly gcNodeUpdated: (
@@ -291,6 +300,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 			"",
 			this.parentContext.IFluidHandleContext,
 		);
+		this.aliasedDataStores = new Set(aliasMap.values());
 
 		// Extract stores stored inside the snapshot
 		const fluidDataStores = new Map<string, ISnapshotTree>();
@@ -338,7 +348,6 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 					}),
 					makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(key),
 					snapshotTree,
-					isRootDataStore: undefined,
 				});
 			}
 			this.contexts.addBoundOrRemoted(dataStoreContext);
@@ -365,7 +374,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	/** For sampling. Only log once per container */
 	private shouldSendAttachLog = true;
 
-	private wrapContextForInnerChannel(id: string): IFluidParentContext {
+	protected wrapContextForInnerChannel(id: string): IFluidParentContext {
 		return wrapContextForInnerChannel(id, this.parentContext);
 	}
 
@@ -415,7 +424,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 				this.pendingAttach.has(attachMessage.id),
 				0x15e /* "Local object does not have matching attach message id" */,
 			);
-			this.contexts.get(attachMessage.id)?.emit("attached");
+			this.contexts.get(attachMessage.id)?.setAttachState(AttachState.Attached);
 			this.pendingAttach.delete(attachMessage.id);
 			return;
 		}
@@ -479,47 +488,44 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		}
 
 		const resolve = localOpMetadata as PendingAliasResolve;
-		const aliasResult = this.processAliasMessageCore(aliasMessage);
+		const aliasResult = this.processAliasMessageCore(
+			aliasMessage.internalId,
+			aliasMessage.alias,
+		);
 		if (local) {
 			resolve(aliasResult);
 		}
 	}
 
-	public processAliasMessageCore(aliasMessage: IDataStoreAliasMessage): boolean {
-		if (this.alreadyProcessed(aliasMessage.alias)) {
+	public processAliasMessageCore(internalId: string, alias: string): boolean {
+		if (this.alreadyProcessed(alias)) {
 			return false;
 		}
 
-		const context = this.contexts.get(aliasMessage.internalId);
+		const context = this.contexts.get(internalId);
 		// If the data store has been deleted, log an error and ignore this message. This helps prevent document
 		// corruption in case a deleted data store accidentally submitted a signal.
-		if (
-			this.checkAndLogIfDeleted(
-				aliasMessage.internalId,
-				context,
-				"Changed",
-				"processAliasMessageCore",
-			)
-		) {
+		if (this.checkAndLogIfDeleted(internalId, context, "Changed", "processAliasMessageCore")) {
 			return false;
 		}
 
 		if (context === undefined) {
 			this.mc.logger.sendErrorEvent({
 				eventName: "AliasFluidDataStoreNotFound",
-				fluidDataStoreId: aliasMessage.internalId,
+				fluidDataStoreId: internalId,
 			});
 			return false;
 		}
 
 		const handle = new FluidObjectHandle(
 			context,
-			aliasMessage.internalId,
+			internalId,
 			this.parentContext.IFluidHandleContext,
 		);
 		this.parentContext.addedGCOutboundReference?.(this.containerRuntimeHandle, handle);
 
-		this.aliasMap.set(aliasMessage.alias, context.id);
+		this.aliasMap.set(alias, context.id);
+		this.aliasedDataStores.add(context.id);
 		context.setInMemoryRoot();
 		return true;
 	}
@@ -529,7 +535,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	}
 
 	/** Package up the context's attach summary etc into an IAttachMessage */
-	private generateAttachMessage(localContext: LocalFluidDataStoreContext): IAttachMessage {
+	private generateAttachMessage(localContext: IFluidDataStoreContextInternal): IAttachMessage {
 		const { attachSummary } = localContext.getAttachData(/* includeGCData: */ true);
 		const type = localContext.packagePath[localContext.packagePath.length - 1];
 
@@ -558,17 +564,20 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		 * If the container is detached, this data store will be part of the summary that makes the container attached.
 		 */
 		if (this.parentContext.attachState !== AttachState.Detached) {
-			localContext.emit("attaching");
-			const message = this.generateAttachMessage(localContext);
-
-			this.pendingAttach.set(id, message);
-			this.parentContext.submitMessage(ContainerMessageType.Attach, message, undefined);
-			this.attachOpFiredForDataStore.add(id);
+			localContext.setAttachState(AttachState.Attaching);
+			this.submitAttachChannelOp(localContext);
 		}
 
 		this.contexts.bind(id);
 	}
 
+	protected submitAttachChannelOp(localContext: LocalFluidDataStoreContext) {
+		const message = this.generateAttachMessage(localContext);
+		this.pendingAttach.set(localContext.id, message);
+		this.parentContext.submitMessage(ContainerMessageType.Attach, message, undefined);
+		this.attachOpFiredForDataStore.add(localContext.id);
+	}
+
 	/**
 	 * Generate compact internal DataStore ID.
 	 *
@@ -602,13 +611,41 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		return id;
 	}
 
-	public createDetachedDataStoreCore(
+	public createDetachedDataStore(
 		pkg: Readonly<string[]>,
 		loadingGroupId?: string,
 	): IFluidDataStoreContextDetached {
-		const id = this.createDataStoreId();
+		return this.createContext(
+			this.createDataStoreId(),
+			pkg,
+			LocalDetachedFluidDataStoreContext,
+			undefined, // props
+			loadingGroupId,
+		);
+	}
+
+	public createDataStoreContext(
+		pkg: Readonly<string[]>,
+		props?: any,
+		loadingGroupId?: string,
+	): IFluidDataStoreContextInternal {
+		return this.createContext(
+			this.createDataStoreId(),
+			pkg,
+			LocalFluidDataStoreContext,
+			props,
+			loadingGroupId,
+		);
+	}
 
-		const context = new LocalDetachedFluidDataStoreContext({
+	protected createContext<T extends LocalFluidDataStoreContext>(
+		id: string,
+		pkg: Readonly<string[]>,
+		contextCtor: new (props: ILocalDetachedFluidDataStoreContextProps) => T,
+		createProps?: any,
+		loadingGroupId?: string,
+	) {
+		const context = new contextCtor({
 			id,
 			pkg,
 			parentContext: this.wrapContextForInnerChannel(id),
@@ -619,7 +656,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 			}),
 			makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(id),
 			snapshotTree: undefined,
-			isRootDataStore: false,
+			createProps,
 			loadingGroupId,
 			channelToDataStoreFn: (channel: IFluidDataStoreChannel) =>
 				channelToDataStore(
@@ -629,31 +666,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 					createChildLogger({ logger: this.parentContext.logger }),
 				),
 		});
-		this.contexts.addUnbound(context);
-		return context;
-	}
 
-	public _createFluidDataStoreContext(
-		pkg: Readonly<string[]>,
-		props?: any,
-		loadingGroupId?: string,
-	) {
-		const id = this.createDataStoreId();
-		const context = new LocalFluidDataStoreContext({
-			id,
-			pkg,
-			parentContext: this.wrapContextForInnerChannel(id),
-			storage: this.parentContext.storage,
-			scope: this.parentContext.scope,
-			createSummarizerNodeFn: this.parentContext.getCreateChildSummarizerNodeFn(id, {
-				type: CreateSummarizerNodeSource.Local,
-			}),
-			makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(id),
-			snapshotTree: undefined,
-			isRootDataStore: false,
-			createProps: props,
-			loadingGroupId,
-		});
 		this.contexts.addUnbound(context);
 		return context;
 	}
@@ -669,10 +682,14 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 			case ContainerMessageType.Alias:
 				this.parentContext.submitMessage(type, content, localOpMetadata);
 				return;
+			case ContainerMessageType.FluidDataStoreOp:
+				return this.reSubmitChannelOp(type, content, localOpMetadata);
 			default:
+				assert(false, 0x907 /* unknown op type */);
 		}
+	}
 
-		assert(type === ContainerMessageType.FluidDataStoreOp, 0x8e7 /* type */);
+	protected reSubmitChannelOp(type: string, content: any, localOpMetadata: unknown) {
 		const envelope = content as IEnvelope;
 		const context = this.contexts.get(envelope.address);
 		// If the data store has been deleted, log an error and throw an error. If there are local changes for a
@@ -716,10 +733,14 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 				return this.applyStashedAttachOp(opContents.contents);
 			case ContainerMessageType.Alias:
 				return;
+			case ContainerMessageType.FluidDataStoreOp:
+				return this.applyStashedChannelChannelOp(opContents.contents);
 			default:
+				assert(false, 0x908 /* unknon type of op */);
 		}
+	}
 
-		const envelope = opContents.contents as IEnvelope;
+	protected async applyStashedChannelChannelOp(envelope: IEnvelope) {
 		const context = this.contexts.get(envelope.address);
 		// If the data store has been deleted, log an error and ignore this message. This helps prevent document
 		// corruption in case the data store that stashed the op is deleted.
@@ -731,9 +752,49 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	}
 
 	private async applyStashedAttachOp(message: IAttachMessage) {
-		this.pendingAttach.set(message.id, message);
-		// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-		this.processAttachMessage({ contents: message } as ISequencedDocumentMessage, false);
+		const { id, snapshot } = message;
+
+		// build the snapshot from the summary in the attach message
+		const flatAttachBlobs = new Map<string, ArrayBufferLike>();
+		const snapshotTree = buildSnapshotTree(snapshot.entries, flatAttachBlobs);
+		const storage = new StorageServiceWithAttachBlobs(
+			this.parentContext.storage,
+			flatAttachBlobs,
+		);
+
+		// create a local datastore context for the data store context,
+		// which this message represents. All newly created data store
+		// contexts start as a local context on the client that created
+		// them, and for stashed ops, the client that applies it plays
+		// the role of creating client.
+		const dataStoreContext = new LocalFluidDataStoreContext({
+			id,
+			pkg: undefined,
+			parentContext: this.wrapContextForInnerChannel(id),
+			storage,
+			scope: this.parentContext.scope,
+			createSummarizerNodeFn: this.parentContext.getCreateChildSummarizerNodeFn(id, {
+				type: CreateSummarizerNodeSource.FromSummary,
+			}),
+			makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(id),
+			snapshotTree,
+		});
+
+		// realize the local context, as local contexts shouldn't be delay
+		// loaded, as this client is playing the role of creating client,
+		// and creating clients always create realized data store contexts.
+		const channel = await dataStoreContext.realize();
+		await channel.entryPoint.get();
+
+		// add to the list of bound or remoted, as this context must be bound
+		// to had an attach message sent, and is the non-detached case is remoted.
+		this.contexts.addBoundOrRemoted(dataStoreContext);
+		if (this.parentContext.attachState !== AttachState.Detached) {
+			// if the client is not detached put in the pending attach list
+			// so that on ack of the stashed op, the context is found.
+			// detached client don't send ops, so should not expect and ack.
+			this.pendingAttach.set(message.id, message);
+		}
 	}
 
 	public process(
@@ -749,32 +810,48 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 			case ContainerMessageType.Alias:
 				this.processAliasMessage(message, localMessageMetadata, local);
 				return;
-			case ContainerMessageType.FluidDataStoreOp:
+			case ContainerMessageType.FluidDataStoreOp: {
+				const envelope = message.contents as IEnvelope;
+				const innerContents = envelope.contents as FluidDataStoreMessage;
+				const transformed = {
+					...message,
+					type: innerContents.type,
+					contents: innerContents.content,
+				};
+
+				this.processChannelOp(envelope.address, transformed, local, localMessageMetadata);
+
+				// By default, we use the new behavior of detecting outbound routes here.
+				// If this setting is true, then DataStoreContext would be notifying GC instead.
+				if (
+					this.mc.config.getBoolean(detectOutboundRoutesViaDDSKey) !== true &&
+					addedOutboundReference !== undefined
+				) {
+					// Notify GC of any outbound references that were added by this op.
+					detectOutboundReferences(
+						envelope.address,
+						transformed.contents,
+						addedOutboundReference,
+					);
+				}
 				break;
+			}
 			default:
 				assert(false, 0x8e9 /* unreached */);
 		}
+	}
 
-		const envelope = message.contents as IEnvelope;
-		const innerContents = envelope.contents as FluidDataStoreMessage;
-		const transformed = {
-			...message,
-			type: innerContents.type,
-			contents: innerContents.content,
-		};
-
-		const context = this.contexts.get(envelope.address);
+	protected processChannelOp(
+		address: string,
+		message: ISequencedDocumentMessage,
+		local: boolean,
+		localMessageMetadata: unknown,
+	) {
+		const context = this.contexts.get(address);
 
 		// If the data store has been deleted, log an error and ignore this message. This helps prevent document
 		// corruption in case a deleted data store accidentally submitted an op.
-		if (
-			this.checkAndLogIfDeleted(
-				envelope.address,
-				context,
-				"Changed",
-				"processFluidDataStoreOp",
-			)
-		) {
+		if (this.checkAndLogIfDeleted(address, context, "Changed", "processFluidDataStoreOp")) {
 			return;
 		}
 
@@ -790,27 +867,17 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 						type: message.type,
 						contentType: typeof message.contents,
 					}),
-					...tagCodeArtifacts({ address: envelope.address }),
+					...tagCodeArtifacts({ address }),
 				},
 			);
 		}
 
-		context.process(transformed, local, localMessageMetadata);
-
-		// By default, we use the new behavior of detecting outbound routes here.
-		// If this setting is true, then DataStoreContext would be notifying GC instead.
-		if (
-			this.mc.config.getBoolean(detectOutboundRoutesViaDDSKey) !== true &&
-			addedOutboundReference !== undefined
-		) {
-			// Notify GC of any outbound references that were added by this op.
-			detectOutboundReferences(envelope, addedOutboundReference);
-		}
+		context.process(message, local, localMessageMetadata);
 
 		// Notify that a GC node for the data store changed. This is used to detect if a deleted data store is
 		// being used.
 		this.gcNodeUpdated(
-			`/${envelope.address}`,
+			`/${address}`,
 			"Changed",
 			message.timestamp,
 			context.isLoaded ? context.packagePath : undefined,
@@ -820,7 +887,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	public async getDataStore(
 		id: string,
 		requestHeaderData: RuntimeHeaderData,
-	): Promise<FluidDataStoreContext> {
+	): Promise<IFluidDataStoreContextInternal> {
 		const headerData = { ...defaultRuntimeHeaderData, ...requestHeaderData };
 		if (
 			this.checkAndLogIfDeleted(
@@ -854,7 +921,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	public async getDataStoreIfAvailable(
 		id: string,
 		requestHeaderData: RuntimeHeaderData,
-	): Promise<FluidDataStoreContext | undefined> {
+	): Promise<IFluidDataStoreContextInternal | undefined> {
 		// If the data store has been deleted, log an error and return undefined.
 		if (
 			this.checkAndLogIfDeleted(
@@ -885,7 +952,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	 */
 	private checkAndLogIfDeleted(
 		id: string,
-		context: FluidDataStoreContext | undefined,
+		context: IFluidDataStoreContext | undefined,
 		deletedLogSuffix: string,
 		callSite: string,
 		requestHeaderData?: RuntimeHeaderData,
@@ -955,11 +1022,10 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	}
 
 	public setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void {
-		const eventName = attachState === AttachState.Attaching ? "attaching" : "attached";
 		for (const [, context] of this.contexts) {
 			// Fire only for bounded stores.
 			if (!this.contexts.isNotBound(context.id)) {
-				context.emit(eventName);
+				context.setAttachState(attachState);
 			}
 		}
 	}
@@ -1144,25 +1210,15 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		}
 	}
 
-	/**
-	 * This is called to update objects whose routes are unused. The unused objects are deleted.
-	 * @param unusedRoutes - The routes that are unused in all data stores in this Container.
-	 */
-	public updateUnusedRoutes(unusedRoutes: readonly string[]) {
-		for (const route of unusedRoutes) {
-			const pathParts = route.split("/");
-			// Delete data store only if its route (/datastoreId) is in unusedRoutes. We don't want to delete a data
-			// store based on its DDS being unused.
-			if (pathParts.length > 2) {
-				continue;
-			}
-			const dataStoreId = pathParts[1];
-			assert(this.contexts.has(dataStoreId), 0x2d7 /* No data store with specified id */);
-			// Delete the contexts of unused data stores.
-			this.contexts.delete(dataStoreId);
-			// Delete the summarizer node of the unused data stores.
-			this.parentContext.deleteChildSummarizerNode?.(dataStoreId);
-		}
+	public deleteChild(dataStoreId: string) {
+		const dataStoreContext = this.contexts.get(dataStoreId);
+		assert(dataStoreContext !== undefined, 0x2d7 /* No data store with specified id */);
+
+		dataStoreContext.delete();
+		// Delete the contexts of unused data stores.
+		this.contexts.delete(dataStoreId);
+		// Delete the summarizer node of the unused data stores.
+		this.parentContext.deleteChildSummarizerNode(dataStoreId);
 	}
 
 	/**
@@ -1198,12 +1254,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 				continue;
 			}
 
-			dataStoreContext.delete();
-
-			// Delete the contexts of sweep ready data stores.
-			this.contexts.delete(dataStoreId);
-			// Delete the summarizer node of the sweep ready data stores.
-			this.parentContext.deleteChildSummarizerNode?.(dataStoreId);
+			this.deleteChild(dataStoreId);
 		}
 		return Array.from(sweepReadyDataStoreRoutes);
 	}
@@ -1241,8 +1292,9 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	 */
 	private async getOutboundRoutes(): Promise<string[]> {
 		const outboundRoutes: string[] = [];
+		// Getting this information is a performance optimization that reduces network calls for virtualized datastores
 		for (const [contextId, context] of this.contexts) {
-			const isRootDataStore = await context.isRoot();
+			const isRootDataStore = await context.isRoot(this.aliasedDataStores);
 			if (isRootDataStore) {
 				outboundRoutes.push(`/${contextId}`);
 			}
@@ -1375,7 +1427,8 @@ export function getSummaryForDatastores(
  * @internal
  */
 export function detectOutboundReferences(
-	envelope: IEnvelope,
+	address: string,
+	contents: unknown,
 	addedOutboundReference: (fromNodePath: string, toNodePath: string) => void,
 ): void {
 	// These will be built up as we traverse the envelope contents
@@ -1402,16 +1455,18 @@ export function detectOutboundReferences(
 		}
 	}
 
-	recursivelyFindHandles(envelope.contents);
+	recursivelyFindHandles(contents);
 
 	// GC node paths are all absolute paths, hence the "" prefix.
 	// e.g. this will yield "/dataStoreId/ddsId"
-	const fromPath = ["", envelope.address, ddsAddress].join("/");
+	const fromPath = ["", address, ddsAddress].join("/");
 	outboundPaths.forEach((toPath) => addedOutboundReference(fromPath, toPath));
 }
 
 /** @internal */
-export class ChannelCollectionFactory implements IFluidDataStoreFactory {
+export class ChannelCollectionFactory<T extends ChannelCollection = ChannelCollection>
+	implements IFluidDataStoreFactory
+{
 	public readonly type = "ChannelCollectionChannel";
 
 	public IFluidDataStoreRegistry: IFluidDataStoreRegistry;
@@ -1422,6 +1477,7 @@ export class ChannelCollectionFactory implements IFluidDataStoreFactory {
 		private readonly provideEntryPoint: (
 			runtime: IFluidDataStoreChannel,
 		) => Promise<FluidObject>,
+		private readonly ctor: (...args: ConstructorParameters<typeof ChannelCollection>) => T,
 	) {
 		this.IFluidDataStoreRegistry = new FluidDataStoreRegistry(registryEntries);
 	}
@@ -1434,7 +1490,7 @@ export class ChannelCollectionFactory implements IFluidDataStoreFactory {
 		context: IFluidDataStoreContext,
 		_existing: boolean,
 	): Promise<IFluidDataStoreChannel> {
-		const runtime = new ChannelCollection(
+		const runtime = this.ctor(
 			context.baseSnapshot,
 			context, // parentContext
 			context.logger,