@fluidframework/container-runtime 2.0.0-dev-rc.1.0.0.232845 → 2.0.0-dev-rc.2.0.0.246488

package/src/{dataStores.ts → channelCollection.ts}

@@ -8,35 +8,44 @@ import {
 	IDisposable,
 	IFluidHandle,
 	IRequest,
+	FluidObject,
+	IResponse,
 } from "@fluidframework/core-interfaces";
 import { FluidObjectHandle } from "@fluidframework/datastore";
 import { ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
 import {
 	AliasResult,
 	channelsTreeName,
-	CreateChildSummarizerNodeFn,
-	CreateChildSummarizerNodeParam,
 	CreateSummarizerNodeSource,
 	IAttachMessage,
 	IEnvelope,
+	IFluidDataStoreChannel,
 	IFluidDataStoreContextDetached,
 	IGarbageCollectionData,
 	IInboundSignalMessage,
+	IFluidParentContext,
 	InboundAttachMessage,
 	ISummarizeResult,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
+	IFluidDataStoreFactory,
+	IFluidDataStoreContext,
+	NamedFluidDataStoreRegistryEntries,
+	IFluidDataStoreRegistry,
 } from "@fluidframework/runtime-definitions";
 import {
 	convertSnapshotTreeToSummaryTree,
-	convertToSummaryTree,
+	convertSummaryTreeToITree,
 	create404Response,
 	createResponseError,
 	GCDataBuilder,
 	isSerializedHandle,
+	processAttachMessageGCData,
 	responseToException,
 	SummaryTreeBuilder,
 	unpackChildNodesUsedRoutes,
+	RequestParser,
+	encodeCompactIdToString,
 } from "@fluidframework/runtime-utils";
 import {
 	createChildMonitoringContext,
@@ -46,41 +55,199 @@ import {
 	LoggingError,
 	MonitoringContext,
 	tagCodeArtifacts,
+	createChildLogger,
 } from "@fluidframework/telemetry-utils";
 import { AttachState } from "@fluidframework/container-definitions";
 import { buildSnapshotTree } from "@fluidframework/driver-utils";
-import { assert, Lazy } from "@fluidframework/core-utils";
-import { v4 as uuid } from "uuid";
-import { DataStoreContexts } from "./dataStoreContexts";
-import { ContainerRuntime, defaultRuntimeHeaderData, RuntimeHeaderData } from "./containerRuntime";
+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";
-import { StorageServiceWithAttachBlobs } from "./storageServiceWithAttachBlobs";
-import { IDataStoreAliasMessage, isDataStoreAliasMessage } from "./dataStore";
-import { GCNodeType, detectOutboundRoutesViaDDSKey, disableDatastoreSweepKey } from "./gc";
-import { IContainerRuntimeMetadata, nonDataStorePaths, rootHasIsolatedChannels } from "./summary";
+	IFluidDataStoreContextInternal,
+	ILocalDetachedFluidDataStoreContextProps,
+} from "./dataStoreContext.js";
+import { StorageServiceWithAttachBlobs } from "./storageServiceWithAttachBlobs.js";
+import {
+	IDataStoreAliasMessage,
+	channelToDataStore,
+	isDataStoreAliasMessage,
+} from "./dataStore.js";
+import {
+	GCNodeType,
+	detectOutboundRoutesViaDDSKey,
+	trimLeadingAndTrailingSlashes,
+} from "./gc/index.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.
+ * @internal
+ */
+export enum RuntimeHeaders {
+	/** True to wait for a data store to be created and loaded before returning it. */
+	wait = "wait",
+	/** True if the request is coming from an IFluidHandle. */
+	viaHandle = "viaHandle",
+}
+
+/** True if a tombstoned object should be returned without erroring
+ * @alpha
+ */
+export const AllowTombstoneRequestHeaderKey = "allowTombstone"; // Belongs in the enum above, but avoiding the breaking change
+/**
+ * [IRRELEVANT IF throwOnInactiveLoad OPTION NOT SET] True if an inactive object should be returned without erroring
+ * @internal
+ */
+export const AllowInactiveRequestHeaderKey = "allowInactive"; // Belongs in the enum above, but avoiding the breaking change
 
 type PendingAliasResolve = (success: boolean) => void;
 
+interface FluidDataStoreMessage {
+	content: any;
+	type: string;
+}
+
+/**
+ * Creates a shallow wrapper of {@link IFluidParentContext}. The wrapper can then have its methods overwritten as needed
+ */
+export function wrapContext(context: IFluidParentContext): IFluidParentContext {
+	return {
+		get IFluidDataStoreRegistry() {
+			return context.IFluidDataStoreRegistry;
+		},
+		IFluidHandleContext: context.IFluidHandleContext,
+		options: context.options,
+		get clientId() {
+			return context.clientId;
+		},
+		get connected() {
+			return context.connected;
+		},
+		deltaManager: context.deltaManager,
+		storage: context.storage,
+		logger: context.logger,
+		get clientDetails() {
+			return context.clientDetails;
+		},
+		get idCompressor() {
+			return context.idCompressor;
+		},
+		loadingGroupId: context.loadingGroupId,
+		get attachState() {
+			return context.attachState;
+		},
+		containerRuntime: context.containerRuntime,
+		scope: context.scope,
+		gcThrowOnTombstoneUsage: context.gcThrowOnTombstoneUsage,
+		gcTombstoneEnforcementAllowed: context.gcTombstoneEnforcementAllowed,
+		getAbsoluteUrl: async (...args) => {
+			return context.getAbsoluteUrl(...args);
+		},
+		getQuorum: (...args) => {
+			return context.getQuorum(...args);
+		},
+		getAudience: (...args) => {
+			return context.getAudience(...args);
+		},
+		ensureNoDataModelChanges: (...args) => {
+			return context.ensureNoDataModelChanges(...args);
+		},
+		submitMessage: (...args) => {
+			return context.submitMessage(...args);
+		},
+		submitSignal: (...args) => {
+			return context.submitSignal(...args);
+		},
+		makeLocallyVisible: (...args) => {
+			return context.makeLocallyVisible(...args);
+		},
+		uploadBlob: async (...args) => {
+			return context.uploadBlob(...args);
+		},
+		addedGCOutboundReference: (...args) => {
+			return context.addedGCOutboundReference?.(...args);
+		},
+		getCreateChildSummarizerNodeFn: (...args) => {
+			return context.getCreateChildSummarizerNodeFn?.(...args);
+		},
+		deleteChildSummarizerNode: (...args) => {
+			return context.deleteChildSummarizerNode(...args);
+		},
+		setChannelDirty: (address: string) => {
+			return context.setChannelDirty(address);
+		},
+	};
+}
+
+/**
+ * Creates a wrapper of a {@link IFluidParentContext} to be provided to the inner datastore channels.
+ * The wrapper will have the submit methods overwritten with the appropriate id as the destination address.
+ *
+ * @param id - the id of the channel
+ * @param parentContext - the {@link IFluidParentContext} to wrap
+ * @returns A wrapped {@link IFluidParentContext}
+ */
+export function wrapContextForInnerChannel(
+	id: string,
+	parentContext: IFluidParentContext,
+): IFluidParentContext {
+	const context = wrapContext(parentContext);
+
+	context.submitMessage = (type: string, content: any, localOpMetadata: unknown) => {
+		const fluidDataStoreContent: FluidDataStoreMessage = {
+			content,
+			type,
+		};
+		const envelope: IEnvelope = {
+			address: id,
+			contents: fluidDataStoreContent,
+		};
+		parentContext.submitMessage(
+			ContainerMessageType.FluidDataStoreOp,
+			envelope,
+			localOpMetadata,
+		);
+	};
+
+	context.submitSignal = (type: string, contents: any, targetClientId?: string) => {
+		const envelope: IEnvelope = {
+			address: id,
+			contents,
+		};
+		parentContext.submitSignal(type, envelope, targetClientId);
+	};
+
+	return context;
+}
+
 /**
  * This class encapsulates data store handling. Currently it is only used by the container runtime,
  * but eventually could be hosted on any channel once we formalize the channel api boundary.
+ * @internal
  */
-export class DataStores implements IDisposable {
+export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	// Stores tracked by the Domain
 	private readonly pendingAttach = new Map<string, IAttachMessage>();
 	// 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());
 
+	public readonly entryPoint: IFluidHandle<FluidObject>;
+
 	public readonly containerLoadStats: {
 		// number of dataStores during loadContainer
 		readonly containerLoadDataStoreCount: number;
@@ -99,30 +266,35 @@ export class DataStores implements IDisposable {
 		Promise<AliasResult>
 	>();
 
+	protected readonly contexts: DataStoreContexts;
+
 	constructor(
-		private readonly baseSnapshot: ISnapshotTree | undefined,
-		private readonly runtime: ContainerRuntime,
-		private readonly submitAttachFn: (attachContent: IAttachMessage) => void,
-		private readonly getCreateChildSummarizerNodeFn: (
-			id: string,
-			createParam: CreateChildSummarizerNodeParam,
-		) => CreateChildSummarizerNodeFn,
-		private readonly deleteChildSummarizerNodeFn: (id: string) => void,
+		protected readonly baseSnapshot: ISnapshotTree | undefined,
+		public readonly parentContext: IFluidParentContext,
 		baseLogger: ITelemetryBaseLogger,
 		private readonly gcNodeUpdated: (
 			nodePath: string,
-			timestampMs: number,
+			reason: "Loaded" | "Changed",
+			timestampMs?: number,
 			packagePath?: readonly string[],
+			request?: IRequest,
+			headerData?: RuntimeHeaderData,
 		) => void,
 		private readonly isDataStoreDeleted: (nodePath: string) => boolean,
 		private readonly aliasMap: Map<string, string>,
-		private readonly contexts: DataStoreContexts = new DataStoreContexts(baseLogger),
+		provideEntryPoint: (runtime: ChannelCollection) => Promise<FluidObject>,
 	) {
 		this.mc = createChildMonitoringContext({ logger: baseLogger });
+		this.contexts = new DataStoreContexts(baseLogger);
 		this.containerRuntimeHandle = new FluidObjectHandle(
-			this.runtime,
+			this.parentContext,
 			"/",
-			this.runtime.IFluidHandleContext,
+			this.parentContext.IFluidHandleContext,
+		);
+		this.entryPoint = new FluidObjectHandle<FluidObject>(
+			new LazyPromise(async () => provideEntryPoint(this)),
+			"",
+			this.parentContext.IFluidHandleContext,
 		);
 
 		// Extract stores stored inside the snapshot
@@ -143,17 +315,17 @@ export class DataStores implements IDisposable {
 				unreferencedDataStoreCount++;
 			}
 			// If we have a detached container, then create local data store contexts.
-			if (this.runtime.attachState !== AttachState.Detached) {
+			if (this.parentContext.attachState !== AttachState.Detached) {
 				dataStoreContext = new RemoteFluidDataStoreContext({
 					id: key,
 					snapshotTree: value,
-					runtime: this.runtime,
-					storage: this.runtime.storage,
-					scope: this.runtime.scope,
-					createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(key, {
+					parentContext: this.wrapContextForInnerChannel(key),
+					storage: this.parentContext.storage,
+					scope: this.parentContext.scope,
+					createSummarizerNodeFn: this.parentContext.getCreateChildSummarizerNodeFn(key, {
 						type: CreateSummarizerNodeSource.FromSummary,
 					}),
-					groupId: value.groupId,
+					loadingGroupId: value.groupId,
 				});
 			} else {
 				if (typeof value !== "object") {
@@ -163,15 +335,14 @@ export class DataStores implements IDisposable {
 				dataStoreContext = new LocalFluidDataStoreContext({
 					id: key,
 					pkg: undefined,
-					runtime: this.runtime,
-					storage: this.runtime.storage,
-					scope: this.runtime.scope,
-					createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(key, {
+					parentContext: this.wrapContextForInnerChannel(key),
+					storage: this.parentContext.storage,
+					scope: this.parentContext.scope,
+					createSummarizerNodeFn: this.parentContext.getCreateChildSummarizerNodeFn(key, {
 						type: CreateSummarizerNodeSource.FromSummary,
 					}),
 					makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(key),
 					snapshotTree,
-					isRootDataStore: undefined,
 				});
 			}
 			this.contexts.addBoundOrRemoted(dataStoreContext);
@@ -195,18 +366,60 @@ export class DataStores implements IDisposable {
 		return pendingAliasPromise ?? "Success";
 	}
 
-	public processAttachMessage(message: ISequencedDocumentMessage, local: boolean) {
+	/** For sampling. Only log once per container */
+	private shouldSendAttachLog = true;
+
+	protected wrapContextForInnerChannel(id: string): IFluidParentContext {
+		return wrapContextForInnerChannel(id, this.parentContext);
+	}
+
+	/**
+	 * IFluidDataStoreChannel.makeVisibleAndAttachGraph implementation
+	 * Not clear when it would be called and what it should do.
+	 * Currently this API is called by context only for root data stores.
+	 */
+	public makeVisibleAndAttachGraph() {
+		this.parentContext.makeLocallyVisible();
+	}
+
+	private processAttachMessage(message: ISequencedDocumentMessage, local: boolean) {
 		const attachMessage = message.contents as InboundAttachMessage;
 
 		this.dataStoresSinceLastGC.push(attachMessage.id);
 
+		// We need to process the GC Data for both local and remote attach messages
+		const foundGCData = processAttachMessageGCData(attachMessage.snapshot, (nodeId, toPath) => {
+			// nodeId is the relative path under the node being attached. Always starts with "/", but no trailing "/" after an id
+			const fromPath = `/${attachMessage.id}${nodeId === "/" ? "" : nodeId}`;
+			this.parentContext.addedGCOutboundReference?.(
+				{ absolutePath: fromPath },
+				{ absolutePath: toPath },
+			);
+		});
+
+		// Only log once per container to avoid noise/cost.
+		// Allows longitudinal tracking of various state (e.g. foundGCData), and some sampled details
+		if (this.shouldSendAttachLog) {
+			this.shouldSendAttachLog = false;
+			this.mc.logger.sendTelemetryEvent({
+				eventName: "dataStoreAttachMessage_sampled",
+				...tagCodeArtifacts({ id: attachMessage.id, pkg: attachMessage.type }),
+				details: {
+					local,
+					snapshot: !!attachMessage.snapshot,
+					foundGCData,
+				},
+				...extractSafePropertiesFromMessage(message),
+			});
+		}
+
 		// The local object has already been attached
 		if (local) {
 			assert(
 				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;
 		}
@@ -237,24 +450,27 @@ export class DataStores implements IDisposable {
 		const remoteFluidDataStoreContext = new RemoteFluidDataStoreContext({
 			id: attachMessage.id,
 			snapshotTree,
-			runtime: this.runtime,
-			storage: new StorageServiceWithAttachBlobs(this.runtime.storage, flatAttachBlobs),
-			scope: this.runtime.scope,
-			groupId: snapshotTree?.groupId,
-			createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(attachMessage.id, {
-				type: CreateSummarizerNodeSource.FromAttach,
-				sequenceNumber: message.sequenceNumber,
-				snapshot: attachMessage.snapshot ?? {
-					entries: [createAttributesBlob(pkg, true /* isRootDataStore */)],
+			parentContext: this.wrapContextForInnerChannel(attachMessage.id),
+			storage: new StorageServiceWithAttachBlobs(this.parentContext.storage, flatAttachBlobs),
+			scope: this.parentContext.scope,
+			loadingGroupId: attachMessage.snapshot?.groupId,
+			createSummarizerNodeFn: this.parentContext.getCreateChildSummarizerNodeFn(
+				attachMessage.id,
+				{
+					type: CreateSummarizerNodeSource.FromAttach,
+					sequenceNumber: message.sequenceNumber,
+					snapshot: attachMessage.snapshot ?? {
+						entries: [createAttributesBlob(pkg, true /* isRootDataStore */)],
+					},
 				},
-			}),
+			),
 			pkg,
 		});
 
 		this.contexts.addBoundOrRemoted(remoteFluidDataStoreContext);
 	}
 
-	public processAliasMessage(
+	private processAliasMessage(
 		message: ISequencedDocumentMessage,
 		localOpMetadata: unknown,
 		local: boolean,
@@ -267,47 +483,43 @@ export class DataStores implements 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,
-			this.runtime.IFluidHandleContext,
+			internalId,
+			this.parentContext.IFluidHandleContext,
 		);
-		this.runtime.addedGCOutboundReference(this.containerRuntimeHandle, handle);
+		this.parentContext.addedGCOutboundReference?.(this.containerRuntimeHandle, handle);
 
-		this.aliasMap.set(aliasMessage.alias, context.id);
+		this.aliasMap.set(alias, context.id);
 		context.setInMemoryRoot();
 		return true;
 	}
@@ -316,9 +528,24 @@ export class DataStores implements IDisposable {
 		return this.aliasMap.get(id) !== undefined || this.contexts.get(id) !== undefined;
 	}
 
+	/** Package up the context's attach summary etc into an IAttachMessage */
+	private generateAttachMessage(localContext: IFluidDataStoreContextInternal): IAttachMessage {
+		const { attachSummary } = localContext.getAttachData(/* includeGCData: */ true);
+		const type = localContext.packagePath[localContext.packagePath.length - 1];
+
+		// Attach message needs the summary in ITree format. Convert the ISummaryTree into an ITree.
+		const snapshot = convertSummaryTreeToITree(attachSummary.summary);
+
+		return {
+			id: localContext.id,
+			snapshot,
+			type,
+		} satisfies IAttachMessage;
+	}
+
 	/**
-	 * Make the data stores locally visible in the container graph by moving the data store context from unbound to
-	 * bound list. This data store can now be reached from the root.
+	 * Make the data store locally visible in the container graph by moving the data store context from unbound to
+	 * bound list and submitting the attach message. This data store can now be reached from the root.
 	 * @param id - The id of the data store context to make visible.
 	 */
 	private makeDataStoreLocallyVisible(id: string): void {
@@ -330,61 +557,110 @@ export class DataStores implements IDisposable {
 		 * globally visible. Move it to attaching state and send an "attach" op for it.
 		 * If the container is detached, this data store will be part of the summary that makes the container attached.
 		 */
-		if (this.runtime.attachState !== AttachState.Detached) {
-			localContext.emit("attaching");
-			const message = localContext.generateAttachMessage();
-
-			this.pendingAttach.set(id, message);
-			this.submitAttachFn(message);
-			this.attachOpFiredForDataStore.add(id);
+		if (this.parentContext.attachState !== AttachState.Detached) {
+			localContext.setAttachState(AttachState.Attaching);
+			this.submitAttachChannelOp(localContext);
 		}
 
 		this.contexts.bind(id);
 	}
 
-	public createDetachedDataStoreCore(
+	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.
+	 *
+	 * A note about namespace and name collisions:
+	 * This code assumes that that's the only way to generate internal IDs, and that it's Ok for this namespace to overlap with
+	 * user-provided alias names namespace.
+	 * There are two scenarios where it could cause trouble:
+	 * 1) Old files, where (already removed) CreateRoot*DataStore*() API was used, and thus internal name of data store
+	 * was provided by user. Such files may experience name collision with future data stores that receive a name generated
+	 * by this function.
+	 * 2) Much less likely, but if it happen that internal ID (generated by this function) is exactly the same as alias name
+	 * that user might use in the future, them ContainerRuntime.getAliasedDataStoreEntryPoint() or
+	 * ContainerRuntime.getDataStoreFromRequest() could return a data store with internalID matching user request, even though
+	 * user expected some other data store (that would receive alias later).
+	 * Please note that above mentioned functions have the implementation they have (allowing #2) due to #1.
+	 */
+	protected createDataStoreId(): string {
+		// We use three non-overlapping namespaces:
+		// - detached state: even numbers
+		// - attached state: odd numbers
+		// - uuids
+		// In first two cases we will encode result as strings in more compact form.
+		if (this.parentContext.attachState === AttachState.Detached) {
+			// container is detached, only one client observes content,  no way to hit collisions with other clients.
+			return encodeCompactIdToString(2 * this.contexts.size);
+		}
+		const id = this.parentContext.containerRuntime.generateDocumentUniqueId();
+		if (typeof id === "number") {
+			return encodeCompactIdToString(2 * id + 1);
+		}
+		return id;
+	}
+
+	public createDetachedDataStore(
 		pkg: Readonly<string[]>,
-		isRoot: boolean,
-		id = uuid(),
-		groupId?: string,
+		loadingGroupId?: string,
 	): IFluidDataStoreContextDetached {
-		assert(!id.includes("/"), 0x30c /* Id cannot contain slashes */);
+		return this.createContext(
+			this.createDataStoreId(),
+			pkg,
+			LocalDetachedFluidDataStoreContext,
+			undefined, // props
+			loadingGroupId,
+		);
+	}
 
-		const context = new LocalDetachedFluidDataStoreContext({
-			id,
+	public createDataStoreContext(
+		pkg: Readonly<string[]>,
+		props?: any,
+		loadingGroupId?: string,
+	): IFluidDataStoreContextInternal {
+		return this.createContext(
+			this.createDataStoreId(),
 			pkg,
-			runtime: this.runtime,
-			storage: this.runtime.storage,
-			scope: this.runtime.scope,
-			createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(id, {
-				type: CreateSummarizerNodeSource.Local,
-			}),
-			makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(id),
-			snapshotTree: undefined,
-			isRootDataStore: isRoot,
-			groupId,
-		});
-		this.contexts.addUnbound(context);
-		return context;
+			LocalFluidDataStoreContext,
+			props,
+			loadingGroupId,
+		);
 	}
 
-	public _createFluidDataStoreContext(pkg: string[], id: string, props?: any, groupId?: string) {
-		assert(!id.includes("/"), 0x30d /* Id cannot contain slashes */);
-		const context = new LocalFluidDataStoreContext({
+	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,
-			runtime: this.runtime,
-			storage: this.runtime.storage,
-			scope: this.runtime.scope,
-			createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(id, {
+			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,
-			groupId,
+			createProps,
+			loadingGroupId,
+			channelToDataStoreFn: (channel: IFluidDataStoreChannel) =>
+				channelToDataStore(
+					channel,
+					id,
+					this,
+					createChildLogger({ logger: this.parentContext.logger }),
+				),
 		});
+
 		this.contexts.addUnbound(context);
 		return context;
 	}
@@ -394,7 +670,21 @@ export class DataStores implements IDisposable {
 	}
 	public readonly dispose = () => this.disposeOnce.value;
 
-	public resubmitDataStoreOp(envelope: IEnvelope, localOpMetadata: unknown) {
+	public reSubmit(type: string, content: any, localOpMetadata: unknown) {
+		switch (type) {
+			case ContainerMessageType.Attach:
+			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 */);
+		}
+	}
+
+	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
 		// deleted data store, it can otherwise lead to inconsistent state when compared to other clients.
@@ -407,10 +697,13 @@ export class DataStores implements IDisposable {
 			});
 		}
 		assert(!!context, 0x160 /* "There should be a store context for the op" */);
-		context.reSubmit(envelope.contents, localOpMetadata);
+		const innerContents = envelope.contents as FluidDataStoreMessage;
+		context.reSubmit(innerContents.type, innerContents.content, localOpMetadata);
 	}
 
-	public rollbackDataStoreOp(envelope: IEnvelope, localOpMetadata: unknown) {
+	public rollback(type: string, content: any, localOpMetadata: unknown) {
+		assert(type === ContainerMessageType.FluidDataStoreOp, 0x8e8 /* type */);
+		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
 		// deleted data store, it can otherwise lead to inconsistent state when compared to other clients.
@@ -423,10 +716,25 @@ export class DataStores implements IDisposable {
 			});
 		}
 		assert(!!context, 0x2e8 /* "There should be a store context for the op" */);
-		context.rollback(envelope.contents, localOpMetadata);
+		const innerContents = envelope.contents as FluidDataStoreMessage;
+		context.rollback(innerContents.type, innerContents.content, localOpMetadata);
+	}
+
+	public async applyStashedOp(content: unknown): Promise<unknown> {
+		const opContents = content as LocalContainerRuntimeMessage;
+		switch (opContents.type) {
+			case ContainerMessageType.Attach:
+				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 */);
+		}
 	}
 
-	public async applyStashedOp(envelope: IEnvelope): Promise<unknown> {
+	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.
@@ -437,49 +745,94 @@ export class DataStores implements IDisposable {
 		return context.applyStashedOp(envelope.contents);
 	}
 
-	public async applyStashedAttachOp(message: IAttachMessage) {
+	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);
 	}
 
-	public processFluidDataStoreOp(
+	public process(
 		message: ISequencedDocumentMessage,
 		local: boolean,
 		localMessageMetadata: unknown,
-		addedOutboundReference: (fromNodePath: string, toNodePath: string) => void,
+		addedOutboundReference?: (fromNodePath: string, toNodePath: string) => void,
 	) {
-		const envelope = message.contents as IEnvelope;
-		const transformed = { ...message, contents: envelope.contents };
-		const context = this.contexts.get(envelope.address);
+		switch (message.type) {
+			case ContainerMessageType.Attach:
+				this.processAttachMessage(message, local);
+				return;
+			case ContainerMessageType.Alias:
+				this.processAliasMessage(message, localMessageMetadata, local);
+				return;
+			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 */);
+		}
+	}
+
+	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;
 		}
 
-		assert(!!context, 0x162 /* "There should be a store context for the op" */);
-		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) {
-			// Notify GC of any outbound references that were added by this op.
-			detectOutboundReferences(envelope, addedOutboundReference);
+		if (context === undefined) {
+			// Former assert 0x162
+			throw DataProcessingError.create(
+				"No context for op",
+				"processFluidDataStoreOp",
+				message,
+				{
+					local,
+					messageDetails: JSON.stringify({
+						type: message.type,
+						contentType: typeof message.contents,
+					}),
+					...tagCodeArtifacts({ address }),
+				},
+			);
 		}
 
+		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,
 		);
@@ -488,7 +841,7 @@ export class DataStores implements IDisposable {
 	public async getDataStore(
 		id: string,
 		requestHeaderData: RuntimeHeaderData,
-	): Promise<FluidDataStoreContext> {
+	): Promise<IFluidDataStoreContextInternal> {
 		const headerData = { ...defaultRuntimeHeaderData, ...requestHeaderData };
 		if (
 			this.checkAndLogIfDeleted(
@@ -522,7 +875,7 @@ export class DataStores implements 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(
@@ -553,7 +906,7 @@ export class DataStores implements IDisposable {
 	 */
 	private checkAndLogIfDeleted(
 		id: string,
-		context: FluidDataStoreContext | undefined,
+		context: IFluidDataStoreContext | undefined,
 		deletedLogSuffix: string,
 		callSite: string,
 		requestHeaderData?: RuntimeHeaderData,
@@ -573,7 +926,10 @@ export class DataStores implements IDisposable {
 		return true;
 	}
 
-	public processSignal(fluidDataStoreId: string, message: IInboundSignalMessage, local: boolean) {
+	public processSignal(messageArg: IInboundSignalMessage, local: boolean) {
+		const envelope = messageArg.content as IEnvelope;
+		const fluidDataStoreId = envelope.address;
+		const message = { ...messageArg, content: envelope.contents };
 		const context = this.contexts.get(fluidDataStoreId);
 		// 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.
@@ -609,7 +965,7 @@ export class DataStores implements IDisposable {
 							fluidDataStoreId,
 						}),
 						details: JSON.stringify({
-							runtimeConnected: this.runtime.connected,
+							runtimeConnected: this.parentContext.connected,
 							connected,
 						}),
 					},
@@ -620,11 +976,10 @@ export class DataStores implements 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);
 			}
 		}
 	}
@@ -670,7 +1025,10 @@ export class DataStores implements IDisposable {
 		return summaryBuilder.getSummaryTree();
 	}
 
-	public createSummary(telemetryContext?: ITelemetryContext): ISummaryTreeWithStats {
+	/**
+	 * Create a summary. Used when attaching or serializing a detached container.
+	 */
+	public getAttachSummary(telemetryContext?: ITelemetryContext): ISummaryTreeWithStats {
 		const builder = new SummaryTreeBuilder();
 		// Attaching graph of some stores can cause other stores to get bound too.
 		// So keep taking summary until no new stores get bound.
@@ -694,8 +1052,10 @@ export class DataStores implements IDisposable {
 				.map(([key, value]) => {
 					let dataStoreSummary: ISummarizeResult;
 					if (value.isLoaded) {
-						const snapshot = value.generateAttachMessage().snapshot;
-						dataStoreSummary = convertToSummaryTree(snapshot, true);
+						dataStoreSummary = value.getAttachData(
+							/* includeGCCData: */ false,
+							telemetryContext,
+						).attachSummary;
 					} else {
 						// If this data store is not yet loaded, then there should be no changes in the snapshot from
 						// which it was created as it is detached container. So just use the previous snapshot.
@@ -725,8 +1085,12 @@ export class DataStores implements IDisposable {
 			assert(context !== undefined, 0x2b6 /* Missing data store context */);
 			if (await context.isRoot()) {
 				// A root data store is basically a reference from the container runtime to the data store.
-				const handle = new FluidObjectHandle(context, id, this.runtime.IFluidHandleContext);
-				this.runtime.addedGCOutboundReference(this.containerRuntimeHandle, handle);
+				const handle = new FluidObjectHandle(
+					context,
+					id,
+					this.parentContext.IFluidHandleContext,
+				);
+				this.parentContext.addedGCOutboundReference?.(this.containerRuntimeHandle, handle);
 			}
 		}
 		this.dataStoresSinceLastGC = [];
@@ -800,25 +1164,15 @@ export class DataStores implements 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.deleteChildSummarizerNodeFn(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);
 	}
 
 	/**
@@ -828,16 +1182,13 @@ export class DataStores implements IDisposable {
 	 * @returns The routes of data stores and its objects that were deleted.
 	 */
 	public deleteSweepReadyNodes(sweepReadyDataStoreRoutes: readonly string[]): readonly string[] {
-		// If sweep for data stores is not enabled, return empty list indicating nothing is deleted.
-		if (this.mc.config.getBoolean(disableDatastoreSweepKey) === true) {
-			return [];
-		}
 		for (const route of sweepReadyDataStoreRoutes) {
 			const pathParts = route.split("/");
 			const dataStoreId = pathParts[1];
 
 			// Ignore sub-data store routes because a data store and its sub-routes are deleted together, so, we only
 			// need to delete the data store.
+			// These routes will still be returned below as among the deleted routes
 			if (pathParts.length > 2) {
 				continue;
 			}
@@ -857,12 +1208,7 @@ export class DataStores implements 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.deleteChildSummarizerNodeFn(dataStoreId);
+			this.deleteChild(dataStoreId);
 		}
 		return Array.from(sweepReadyDataStoreRoutes);
 	}
@@ -936,6 +1282,69 @@ export class DataStores implements IDisposable {
 		}
 		return GCNodeType.SubDataStore;
 	}
+
+	public internalId(maybeAlias: string): string {
+		return this.aliases.get(maybeAlias) ?? maybeAlias;
+	}
+
+	public async request(request: IRequest): Promise<IResponse> {
+		const requestParser = RequestParser.create(request);
+		const id = requestParser.pathParts[0];
+
+		// Differentiate between requesting the dataStore directly, or one of its children
+		const requestForChild = !requestParser.isLeaf(1);
+
+		const headerData: RuntimeHeaderData = {};
+		if (typeof request.headers?.[RuntimeHeaders.wait] === "boolean") {
+			headerData.wait = request.headers[RuntimeHeaders.wait];
+		}
+		if (typeof request.headers?.[RuntimeHeaders.viaHandle] === "boolean") {
+			headerData.viaHandle = request.headers[RuntimeHeaders.viaHandle];
+		}
+		if (typeof request.headers?.[AllowTombstoneRequestHeaderKey] === "boolean") {
+			headerData.allowTombstone = request.headers[AllowTombstoneRequestHeaderKey];
+		}
+		if (typeof request.headers?.[AllowInactiveRequestHeaderKey] === "boolean") {
+			headerData.allowInactive = request.headers[AllowInactiveRequestHeaderKey];
+		}
+
+		// We allow Tombstone requests for sub-DataStore objects
+		if (requestForChild) {
+			headerData.allowTombstone = true;
+		}
+
+		await this.waitIfPendingAlias(id);
+		const internalId = this.internalId(id);
+		const dataStoreContext = await this.getDataStore(internalId, headerData);
+
+		// Remove query params, leading and trailing slashes from the url. This is done to make sure the format is
+		// the same as GC nodes id.
+		const urlWithoutQuery = trimLeadingAndTrailingSlashes(request.url.split("?")[0]);
+		// Get the initial snapshot details which contain the data store package path.
+		const details = await dataStoreContext.getInitialSnapshotDetails();
+
+		// Note that this will throw if the data store is inactive or tombstoned and throwing on incorrect usage
+		// is configured.
+		this.gcNodeUpdated(
+			`/${urlWithoutQuery}`,
+			"Loaded",
+			undefined /* timestampMs */,
+			details.pkg,
+			request,
+			headerData,
+		);
+		const dataStore = await dataStoreContext.realize();
+
+		const subRequest = requestParser.createSubRequest(1);
+		// We always expect createSubRequest to include a leading slash, but asserting here to protect against
+		// unintentionally modifying the url if that changes.
+		assert(
+			subRequest.url.startsWith("/"),
+			0x126 /* "Expected createSubRequest url to include a leading slash" */,
+		);
+
+		return dataStore.request(subRequest);
+	}
 }
 
 export function getSummaryForDatastores(
@@ -971,7 +1380,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
@@ -998,10 +1408,51 @@ 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<T extends ChannelCollection = ChannelCollection>
+	implements IFluidDataStoreFactory
+{
+	public readonly type = "ChannelCollectionChannel";
+
+	public IFluidDataStoreRegistry: IFluidDataStoreRegistry;
+
+	constructor(
+		registryEntries: NamedFluidDataStoreRegistryEntries,
+		// ADO:7302 We need a better type here
+		private readonly provideEntryPoint: (
+			runtime: IFluidDataStoreChannel,
+		) => Promise<FluidObject>,
+		private readonly ctor: (...args: ConstructorParameters<typeof ChannelCollection>) => T,
+	) {
+		this.IFluidDataStoreRegistry = new FluidDataStoreRegistry(registryEntries);
+	}
+
+	public get IFluidDataStoreFactory() {
+		return this;
+	}
+
+	public async instantiateDataStore(
+		context: IFluidDataStoreContext,
+		_existing: boolean,
+	): Promise<IFluidDataStoreChannel> {
+		const runtime = this.ctor(
+			context.baseSnapshot,
+			context, // parentContext
+			context.logger,
+			() => {}, // gcNodeUpdated
+			(_nodePath: string) => false, // isDataStoreDeleted
+			new Map(), // aliasMap
+			this.provideEntryPoint,
+		);
+
+		return runtime;
+	}
+}