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

package/lib/{dataStores.mjs → channelCollection.js}

@@ -4,34 +4,150 @@
  */
 import { FluidObjectHandle } from "@fluidframework/datastore";
 import { channelsTreeName, CreateSummarizerNodeSource, } from "@fluidframework/runtime-definitions";
-import { convertSnapshotTreeToSummaryTree, convertToSummaryTree, create404Response, createResponseError, GCDataBuilder, isSerializedHandle, responseToException, SummaryTreeBuilder, unpackChildNodesUsedRoutes, } from "@fluidframework/runtime-utils";
-import { createChildMonitoringContext, DataCorruptionError, DataProcessingError, extractSafePropertiesFromMessage, LoggingError, tagCodeArtifacts, } from "@fluidframework/telemetry-utils";
+import { convertSnapshotTreeToSummaryTree, convertSummaryTreeToITree, create404Response, createResponseError, GCDataBuilder, isSerializedHandle, processAttachMessageGCData, responseToException, SummaryTreeBuilder, unpackChildNodesUsedRoutes, RequestParser, encodeCompactIdToString, } from "@fluidframework/runtime-utils";
+import { createChildMonitoringContext, DataCorruptionError, DataProcessingError, extractSafePropertiesFromMessage, LoggingError, 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.mjs";
-import { defaultRuntimeHeaderData } from "./containerRuntime.mjs";
-import { RemoteFluidDataStoreContext, LocalFluidDataStoreContext, createAttributesBlob, LocalDetachedFluidDataStoreContext, } from "./dataStoreContext.mjs";
-import { StorageServiceWithAttachBlobs } from "./storageServiceWithAttachBlobs.mjs";
-import { GCNodeType, detectOutboundRoutesViaDDSKey } from "./gc/index.mjs";
-import { isDataStoreAliasMessage } from "./dataStore.mjs";
-import { nonDataStorePaths, rootHasIsolatedChannels } from "./summary/index.mjs";
+import { assert, Lazy, LazyPromise } from "@fluidframework/core-utils";
+import { DataStoreContexts } from "./dataStoreContexts.js";
+import { defaultRuntimeHeaderData } from "./containerRuntime.js";
+import { RemoteFluidDataStoreContext, LocalFluidDataStoreContext, createAttributesBlob, LocalDetachedFluidDataStoreContext, } from "./dataStoreContext.js";
+import { StorageServiceWithAttachBlobs } from "./storageServiceWithAttachBlobs.js";
+import { channelToDataStore, isDataStoreAliasMessage, } from "./dataStore.js";
+import { GCNodeType, detectOutboundRoutesViaDDSKey, trimLeadingAndTrailingSlashes, } from "./gc/index.js";
+import { nonDataStorePaths, rootHasIsolatedChannels, } from "./summary/index.js";
+import { ContainerMessageType } from "./messageTypes.js";
+import { FluidDataStoreRegistry } from "./dataStoreRegistry.js";
+/**
+ * Accepted header keys for requests coming to the runtime.
+ * @internal
+ */
+export var RuntimeHeaders;
+(function (RuntimeHeaders) {
+    /** True to wait for a data store to be created and loaded before returning it. */
+    RuntimeHeaders["wait"] = "wait";
+    /** True if the request is coming from an IFluidHandle. */
+    RuntimeHeaders["viaHandle"] = "viaHandle";
+})(RuntimeHeaders || (RuntimeHeaders = {}));
+/** 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
+/**
+ * Creates a shallow wrapper of {@link IFluidParentContext}. The wrapper can then have its methods overwritten as needed
+ */
+export function wrapContext(context) {
+    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);
+        },
+    };
+}
+/**
+ * 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, parentContext) {
+    const context = wrapContext(parentContext);
+    context.submitMessage = (type, content, localOpMetadata) => {
+        const fluidDataStoreContent = {
+            content,
+            type,
+        };
+        const envelope = {
+            address: id,
+            contents: fluidDataStoreContent,
+        };
+        parentContext.submitMessage(ContainerMessageType.FluidDataStoreOp, envelope, localOpMetadata);
+    };
+    context.submitSignal = (type, contents, targetClientId) => {
+        const envelope = {
+            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 {
-    constructor(baseSnapshot, runtime, submitAttachFn, getCreateChildSummarizerNodeFn, deleteChildSummarizerNodeFn, baseLogger, gcNodeUpdated, isDataStoreDeleted, aliasMap, contexts = new DataStoreContexts(baseLogger)) {
+export class ChannelCollection {
+    constructor(baseSnapshot, parentContext, baseLogger, gcNodeUpdated, isDataStoreDeleted, aliasMap, provideEntryPoint) {
         this.baseSnapshot = baseSnapshot;
-        this.runtime = runtime;
-        this.submitAttachFn = submitAttachFn;
-        this.getCreateChildSummarizerNodeFn = getCreateChildSummarizerNodeFn;
-        this.deleteChildSummarizerNodeFn = deleteChildSummarizerNodeFn;
+        this.parentContext = parentContext;
         this.gcNodeUpdated = gcNodeUpdated;
         this.isDataStoreDeleted = isDataStoreDeleted;
         this.aliasMap = aliasMap;
-        this.contexts = contexts;
         // Stores tracked by the Domain
         this.pendingAttach = new Map();
         // 0.24 back-compat attachingBeforeSummary
@@ -41,9 +157,13 @@ export class DataStores {
         // root data stores that are added.
         this.dataStoresSinceLastGC = [];
         this.pendingAliasMap = new Map();
+        /** For sampling. Only log once per container */
+        this.shouldSendAttachLog = true;
         this.dispose = () => this.disposeOnce.value;
         this.mc = createChildMonitoringContext({ logger: baseLogger });
-        this.containerRuntimeHandle = new FluidObjectHandle(this.runtime, "/", this.runtime.IFluidHandleContext);
+        this.contexts = new DataStoreContexts(baseLogger);
+        this.containerRuntimeHandle = new FluidObjectHandle(this.parentContext, "/", this.parentContext.IFluidHandleContext);
+        this.entryPoint = new FluidObjectHandle(new LazyPromise(async () => provideEntryPoint(this)), "", this.parentContext.IFluidHandleContext);
         // Extract stores stored inside the snapshot
         const fluidDataStores = new Map();
         if (baseSnapshot) {
@@ -60,16 +180,17 @@ export class DataStores {
                 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,
                     }),
+                    loadingGroupId: value.groupId,
                 });
             }
             else {
@@ -80,10 +201,10 @@ export class DataStores {
                 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),
@@ -108,9 +229,41 @@ export class DataStores {
         const pendingAliasPromise = this.pendingAliases.get(maybeAlias);
         return pendingAliasPromise ?? "Success";
     }
+    wrapContextForInnerChannel(id) {
+        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.
+     */
+    makeVisibleAndAttachGraph() {
+        this.parentContext.makeLocallyVisible();
+    }
     processAttachMessage(message, local) {
         const attachMessage = message.contents;
         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" */);
@@ -140,10 +293,11 @@ export class DataStores {
         const remoteFluidDataStoreContext = new RemoteFluidDataStoreContext({
             id: attachMessage.id,
             snapshotTree,
-            runtime: this.runtime,
-            storage: new StorageServiceWithAttachBlobs(this.runtime.storage, flatAttachBlobs),
-            scope: this.runtime.scope,
-            createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(attachMessage.id, {
+            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 ?? {
@@ -184,8 +338,8 @@ export class DataStores {
             });
             return false;
         }
-        const handle = new FluidObjectHandle(context, aliasMessage.internalId, this.runtime.IFluidHandleContext);
-        this.runtime.addedGCOutboundReference(this.containerRuntimeHandle, handle);
+        const handle = new FluidObjectHandle(context, aliasMessage.internalId, this.parentContext.IFluidHandleContext);
+        this.parentContext.addedGCOutboundReference?.(this.containerRuntimeHandle, handle);
         this.aliasMap.set(aliasMessage.alias, context.id);
         context.setInMemoryRoot();
         return true;
@@ -193,9 +347,21 @@ export class DataStores {
     alreadyProcessed(id) {
         return this.aliasMap.get(id) !== undefined || this.contexts.get(id) !== undefined;
     }
+    /** Package up the context's attach summary etc into an IAttachMessage */
+    generateAttachMessage(localContext) {
+        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,
+        };
+    }
     /**
-     * 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.
      */
     makeDataStoreLocallyVisible(id) {
@@ -206,48 +372,83 @@ export class DataStores {
          * 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) {
+        if (this.parentContext.attachState !== AttachState.Detached) {
             localContext.emit("attaching");
-            const message = localContext.generateAttachMessage();
+            const message = this.generateAttachMessage(localContext);
             this.pendingAttach.set(id, message);
-            this.submitAttachFn(message);
+            this.parentContext.submitMessage(ContainerMessageType.Attach, message, undefined);
             this.attachOpFiredForDataStore.add(id);
         }
         this.contexts.bind(id);
     }
-    createDetachedDataStoreCore(pkg, isRoot, id = uuid()) {
-        assert(!id.includes("/"), 0x30c /* Id cannot contain slashes */);
+    /**
+     * 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.
+     */
+    createDataStoreId() {
+        // 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;
+    }
+    createDetachedDataStoreCore(pkg, loadingGroupId) {
+        const id = this.createDataStoreId();
         const context = new LocalDetachedFluidDataStoreContext({
             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: isRoot,
+            isRootDataStore: false,
+            loadingGroupId,
+            channelToDataStoreFn: (channel) => channelToDataStore(channel, id, this, createChildLogger({ logger: this.parentContext.logger })),
         });
         this.contexts.addUnbound(context);
         return context;
     }
-    _createFluidDataStoreContext(pkg, id, props) {
-        assert(!id.includes("/"), 0x30d /* Id cannot contain slashes */);
+    _createFluidDataStoreContext(pkg, props, loadingGroupId) {
+        const id = this.createDataStoreId();
         const context = new LocalFluidDataStoreContext({
             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,
+            loadingGroupId,
         });
         this.contexts.addUnbound(context);
         return context;
@@ -255,7 +456,16 @@ export class DataStores {
     get disposed() {
         return this.disposeOnce.evaluated;
     }
-    resubmitDataStoreOp(envelope, localOpMetadata) {
+    reSubmit(type, content, localOpMetadata) {
+        switch (type) {
+            case ContainerMessageType.Attach:
+            case ContainerMessageType.Alias:
+                this.parentContext.submitMessage(type, content, localOpMetadata);
+                return;
+            default:
+        }
+        assert(type === ContainerMessageType.FluidDataStoreOp, 0x8e7 /* type */);
+        const envelope = content;
         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.
@@ -266,9 +476,12 @@ export class DataStores {
             });
         }
         assert(!!context, 0x160 /* "There should be a store context for the op" */);
-        context.reSubmit(envelope.contents, localOpMetadata);
+        const innerContents = envelope.contents;
+        context.reSubmit(innerContents.type, innerContents.content, localOpMetadata);
     }
-    rollbackDataStoreOp(envelope, localOpMetadata) {
+    rollback(type, content, localOpMetadata) {
+        assert(type === ContainerMessageType.FluidDataStoreOp, 0x8e8 /* type */);
+        const envelope = content;
         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.
@@ -279,9 +492,19 @@ export class DataStores {
             });
         }
         assert(!!context, 0x2e8 /* "There should be a store context for the op" */);
-        context.rollback(envelope.contents, localOpMetadata);
+        const innerContents = envelope.contents;
+        context.rollback(innerContents.type, innerContents.content, localOpMetadata);
     }
-    async applyStashedOp(envelope) {
+    async applyStashedOp(content) {
+        const opContents = content;
+        switch (opContents.type) {
+            case ContainerMessageType.Attach:
+                return this.applyStashedAttachOp(opContents.contents);
+            case ContainerMessageType.Alias:
+                return;
+            default:
+        }
+        const envelope = opContents.contents;
         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.
@@ -296,9 +519,26 @@ export class DataStores {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         this.processAttachMessage({ contents: message }, false);
     }
-    processFluidDataStoreOp(message, local, localMessageMetadata, addedOutboundReference) {
+    process(message, local, localMessageMetadata, addedOutboundReference) {
+        switch (message.type) {
+            case ContainerMessageType.Attach:
+                this.processAttachMessage(message, local);
+                return;
+            case ContainerMessageType.Alias:
+                this.processAliasMessage(message, localMessageMetadata, local);
+                return;
+            case ContainerMessageType.FluidDataStoreOp:
+                break;
+            default:
+                assert(false, 0x8e9 /* unreached */);
+        }
         const envelope = message.contents;
-        const transformed = { ...message, contents: envelope.contents };
+        const innerContents = envelope.contents;
+        const transformed = {
+            ...message,
+            type: innerContents.type,
+            contents: innerContents.content,
+        };
         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 a deleted data store accidentally submitted an op.
@@ -319,13 +559,14 @@ export class DataStores {
         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) {
+        if (this.mc.config.getBoolean(detectOutboundRoutesViaDDSKey) !== true &&
+            addedOutboundReference !== undefined) {
             // Notify GC of any outbound references that were added by this op.
             detectOutboundReferences(envelope, addedOutboundReference);
         }
         // 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}`, message.timestamp, context.isLoaded ? context.packagePath : undefined);
+        this.gcNodeUpdated(`/${envelope.address}`, "Changed", message.timestamp, context.isLoaded ? context.packagePath : undefined);
     }
     async getDataStore(id, requestHeaderData) {
         const headerData = { ...defaultRuntimeHeaderData, ...requestHeaderData };
@@ -379,7 +620,10 @@ export class DataStores {
         });
         return true;
     }
-    processSignal(fluidDataStoreId, message, local) {
+    processSignal(messageArg, local) {
+        const envelope = messageArg.content;
+        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.
@@ -412,7 +656,7 @@ export class DataStores {
                         fluidDataStoreId,
                     }),
                     details: JSON.stringify({
-                        runtimeConnected: this.runtime.connected,
+                        runtimeConnected: this.parentContext.connected,
                         connected,
                     }),
                 }, error);
@@ -452,7 +696,10 @@ export class DataStores {
         }));
         return summaryBuilder.getSummaryTree();
     }
-    createSummary(telemetryContext) {
+    /**
+     * Create a summary. Used when attaching or serializing a detached container.
+     */
+    getAttachSummary(telemetryContext) {
         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.
@@ -472,8 +719,8 @@ export class DataStores {
                 .map(([key, value]) => {
                 let dataStoreSummary;
                 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
@@ -497,8 +744,8 @@ export class DataStores {
             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 = [];
@@ -574,7 +821,7 @@ export class DataStores {
             // Delete the contexts of unused data stores.
             this.contexts.delete(dataStoreId);
             // Delete the summarizer node of the unused data stores.
-            this.deleteChildSummarizerNodeFn(dataStoreId);
+            this.parentContext.deleteChildSummarizerNode?.(dataStoreId);
         }
     }
     /**
@@ -611,7 +858,7 @@ export class DataStores {
             // 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.parentContext.deleteChildSummarizerNode?.(dataStoreId);
         }
         return Array.from(sweepReadyDataStoreRoutes);
     }
@@ -679,6 +926,49 @@ export class DataStores {
         }
         return GCNodeType.SubDataStore;
     }
+    internalId(maybeAlias) {
+        return this.aliases.get(maybeAlias) ?? maybeAlias;
+    }
+    async request(request) {
+        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 = {};
+        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(snapshot, metadata) {
     if (!snapshot) {
@@ -705,6 +995,8 @@ export function getSummaryForDatastores(snapshot, metadata) {
 }
 /**
  * Traverse this op's contents and detect any outbound routes that were added by this op.
+ *
+ * @internal
  */
 export function detectOutboundReferences(envelope, addedOutboundReference) {
     // These will be built up as we traverse the envelope contents
@@ -733,4 +1025,25 @@ export function detectOutboundReferences(envelope, addedOutboundReference) {
     const fromPath = ["", envelope.address, ddsAddress].join("/");
     outboundPaths.forEach((toPath) => addedOutboundReference(fromPath, toPath));
 }
-//# sourceMappingURL=dataStores.mjs.map
+/** @internal */
+export class ChannelCollectionFactory {
+    constructor(registryEntries, 
+    // ADO:7302 We need a better type here
+    provideEntryPoint) {
+        this.provideEntryPoint = provideEntryPoint;
+        this.type = "ChannelCollectionChannel";
+        this.IFluidDataStoreRegistry = new FluidDataStoreRegistry(registryEntries);
+    }
+    get IFluidDataStoreFactory() {
+        return this;
+    }
+    async instantiateDataStore(context, _existing) {
+        const runtime = new ChannelCollection(context.baseSnapshot, context, // parentContext
+        context.logger, () => { }, // gcNodeUpdated
+        (_nodePath) => false, // isDataStoreDeleted
+        new Map(), // aliasMap
+        this.provideEntryPoint);
+        return runtime;
+    }
+}
+//# sourceMappingURL=channelCollection.js.map