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

package/dist/{dataStores.js → channelCollection.js}

@@ -4,7 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectOutboundReferences = exports.getSummaryForDatastores = exports.DataStores = void 0;
+exports.ChannelCollectionFactory = exports.detectOutboundReferences = exports.getSummaryForDatastores = exports.ChannelCollection = exports.wrapContextForInnerChannel = exports.wrapContext = exports.AllowInactiveRequestHeaderKey = exports.AllowTombstoneRequestHeaderKey = exports.RuntimeHeaders = void 0;
 const datastore_1 = require("@fluidframework/datastore");
 const runtime_definitions_1 = require("@fluidframework/runtime-definitions");
 const runtime_utils_1 = require("@fluidframework/runtime-utils");
@@ -12,29 +12,150 @@ const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 const container_definitions_1 = require("@fluidframework/container-definitions");
 const driver_utils_1 = require("@fluidframework/driver-utils");
 const core_utils_1 = require("@fluidframework/core-utils");
-const uuid_1 = require("uuid");
-const dataStoreContexts_1 = require("./dataStoreContexts");
-const containerRuntime_1 = require("./containerRuntime");
-const dataStoreContext_1 = require("./dataStoreContext");
-const storageServiceWithAttachBlobs_1 = require("./storageServiceWithAttachBlobs");
-const dataStore_1 = require("./dataStore");
-const gc_1 = require("./gc");
-const summary_1 = require("./summary");
+const dataStoreContexts_js_1 = require("./dataStoreContexts.js");
+const containerRuntime_js_1 = require("./containerRuntime.js");
+const dataStoreContext_js_1 = require("./dataStoreContext.js");
+const storageServiceWithAttachBlobs_js_1 = require("./storageServiceWithAttachBlobs.js");
+const dataStore_js_1 = require("./dataStore.js");
+const index_js_1 = require("./gc/index.js");
+const index_js_2 = require("./summary/index.js");
+const messageTypes_js_1 = require("./messageTypes.js");
+const dataStoreRegistry_js_1 = require("./dataStoreRegistry.js");
+/**
+ * Accepted header keys for requests coming to the runtime.
+ * @internal
+ */
+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 || (exports.RuntimeHeaders = RuntimeHeaders = {}));
+/** True if a tombstoned object should be returned without erroring
+ * @alpha
+ */
+exports.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
+ */
+exports.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
+ */
+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);
+        },
+        setChannelDirty: (address) => {
+            return context.setChannelDirty(address);
+        },
+    };
+}
+exports.wrapContext = wrapContext;
+/**
+ * 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}
+ */
+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(messageTypes_js_1.ContainerMessageType.FluidDataStoreOp, envelope, localOpMetadata);
+    };
+    context.submitSignal = (type, contents, targetClientId) => {
+        const envelope = {
+            address: id,
+            contents,
+        };
+        parentContext.submitSignal(type, envelope, targetClientId);
+    };
+    return context;
+}
+exports.wrapContextForInnerChannel = wrapContextForInnerChannel;
 /**
  * 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
  */
-class DataStores {
-    constructor(baseSnapshot, runtime, submitAttachFn, getCreateChildSummarizerNodeFn, deleteChildSummarizerNodeFn, baseLogger, gcNodeUpdated, isDataStoreDeleted, aliasMap, contexts = new dataStoreContexts_1.DataStoreContexts(baseLogger)) {
+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
@@ -44,9 +165,13 @@ 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 = (0, telemetry_utils_1.createChildMonitoringContext)({ logger: baseLogger });
-        this.containerRuntimeHandle = new datastore_1.FluidObjectHandle(this.runtime, "/", this.runtime.IFluidHandleContext);
+        this.contexts = new dataStoreContexts_js_1.DataStoreContexts(baseLogger);
+        this.containerRuntimeHandle = new datastore_1.FluidObjectHandle(this.parentContext, "/", this.parentContext.IFluidHandleContext);
+        this.entryPoint = new datastore_1.FluidObjectHandle(new core_utils_1.LazyPromise(async () => provideEntryPoint(this)), "", this.parentContext.IFluidHandleContext);
         // Extract stores stored inside the snapshot
         const fluidDataStores = new Map();
         if (baseSnapshot) {
@@ -63,17 +188,17 @@ class DataStores {
                 unreferencedDataStoreCount++;
             }
             // If we have a detached container, then create local data store contexts.
-            if (this.runtime.attachState !== container_definitions_1.AttachState.Detached) {
-                dataStoreContext = new dataStoreContext_1.RemoteFluidDataStoreContext({
+            if (this.parentContext.attachState !== container_definitions_1.AttachState.Detached) {
+                dataStoreContext = new dataStoreContext_js_1.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: runtime_definitions_1.CreateSummarizerNodeSource.FromSummary,
                     }),
-                    groupId: value.groupId,
+                    loadingGroupId: value.groupId,
                 });
             }
             else {
@@ -81,18 +206,17 @@ class DataStores {
                     throw new telemetry_utils_1.LoggingError("Snapshot should be there to load from!!");
                 }
                 const snapshotTree = value;
-                dataStoreContext = new dataStoreContext_1.LocalFluidDataStoreContext({
+                dataStoreContext = new dataStoreContext_js_1.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: runtime_definitions_1.CreateSummarizerNodeSource.FromSummary,
                     }),
                     makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(key),
                     snapshotTree,
-                    isRootDataStore: undefined,
                 });
             }
             this.contexts.addBoundOrRemoted(dataStoreContext);
@@ -112,13 +236,45 @@ 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 = (0, runtime_utils_1.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",
+                ...(0, telemetry_utils_1.tagCodeArtifacts)({ id: attachMessage.id, pkg: attachMessage.type }),
+                details: {
+                    local,
+                    snapshot: !!attachMessage.snapshot,
+                    foundGCData,
+                },
+                ...(0, telemetry_utils_1.extractSafePropertiesFromMessage)(message),
+            });
+        }
         // The local object has already been attached
         if (local) {
             (0, core_utils_1.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(container_definitions_1.AttachState.Attached);
             this.pendingAttach.delete(attachMessage.id);
             return;
         }
@@ -141,18 +297,18 @@ class DataStores {
         // Include the type of attach message which is the pkg of the store to be
         // used by RemoteFluidDataStoreContext in case it is not in the snapshot.
         const pkg = [attachMessage.type];
-        const remoteFluidDataStoreContext = new dataStoreContext_1.RemoteFluidDataStoreContext({
+        const remoteFluidDataStoreContext = new dataStoreContext_js_1.RemoteFluidDataStoreContext({
             id: attachMessage.id,
             snapshotTree,
-            runtime: this.runtime,
-            storage: new storageServiceWithAttachBlobs_1.StorageServiceWithAttachBlobs(this.runtime.storage, flatAttachBlobs),
-            scope: this.runtime.scope,
-            groupId: snapshotTree?.groupId,
-            createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(attachMessage.id, {
+            parentContext: this.wrapContextForInnerChannel(attachMessage.id),
+            storage: new storageServiceWithAttachBlobs_js_1.StorageServiceWithAttachBlobs(this.parentContext.storage, flatAttachBlobs),
+            scope: this.parentContext.scope,
+            loadingGroupId: attachMessage.snapshot?.groupId,
+            createSummarizerNodeFn: this.parentContext.getCreateChildSummarizerNodeFn(attachMessage.id, {
                 type: runtime_definitions_1.CreateSummarizerNodeSource.FromAttach,
                 sequenceNumber: message.sequenceNumber,
                 snapshot: attachMessage.snapshot ?? {
-                    entries: [(0, dataStoreContext_1.createAttributesBlob)(pkg, true /* isRootDataStore */)],
+                    entries: [(0, dataStoreContext_js_1.createAttributesBlob)(pkg, true /* isRootDataStore */)],
                 },
             }),
             pkg,
@@ -161,46 +317,58 @@ class DataStores {
     }
     processAliasMessage(message, localOpMetadata, local) {
         const aliasMessage = message.contents;
-        if (!(0, dataStore_1.isDataStoreAliasMessage)(aliasMessage)) {
+        if (!(0, dataStore_js_1.isDataStoreAliasMessage)(aliasMessage)) {
             throw new telemetry_utils_1.DataCorruptionError("malformedDataStoreAliasMessage", {
                 ...(0, telemetry_utils_1.extractSafePropertiesFromMessage)(message),
             });
         }
         const resolve = localOpMetadata;
-        const aliasResult = this.processAliasMessageCore(aliasMessage);
+        const aliasResult = this.processAliasMessageCore(aliasMessage.internalId, aliasMessage.alias);
         if (local) {
             resolve(aliasResult);
         }
     }
-    processAliasMessageCore(aliasMessage) {
-        if (this.alreadyProcessed(aliasMessage.alias)) {
+    processAliasMessageCore(internalId, alias) {
+        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 datastore_1.FluidObjectHandle(context, aliasMessage.internalId, this.runtime.IFluidHandleContext);
-        this.runtime.addedGCOutboundReference(this.containerRuntimeHandle, handle);
-        this.aliasMap.set(aliasMessage.alias, context.id);
+        const handle = new datastore_1.FluidObjectHandle(context, internalId, this.parentContext.IFluidHandleContext);
+        this.parentContext.addedGCOutboundReference?.(this.containerRuntimeHandle, handle);
+        this.aliasMap.set(alias, context.id);
         context.setInMemoryRoot();
         return true;
     }
     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 = (0, runtime_utils_1.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) {
@@ -211,50 +379,72 @@ 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 !== container_definitions_1.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 !== container_definitions_1.AttachState.Detached) {
+            localContext.setAttachState(container_definitions_1.AttachState.Attaching);
+            this.submitAttachChannelOp(localContext);
         }
         this.contexts.bind(id);
     }
-    createDetachedDataStoreCore(pkg, isRoot, id = (0, uuid_1.v4)(), groupId) {
-        (0, core_utils_1.assert)(!id.includes("/"), 0x30c /* Id cannot contain slashes */);
-        const context = new dataStoreContext_1.LocalDetachedFluidDataStoreContext({
-            id,
-            pkg,
-            runtime: this.runtime,
-            storage: this.runtime.storage,
-            scope: this.runtime.scope,
-            createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(id, {
-                type: runtime_definitions_1.CreateSummarizerNodeSource.Local,
-            }),
-            makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(id),
-            snapshotTree: undefined,
-            isRootDataStore: isRoot,
-            groupId,
-        });
-        this.contexts.addUnbound(context);
-        return context;
+    submitAttachChannelOp(localContext) {
+        const message = this.generateAttachMessage(localContext);
+        this.pendingAttach.set(localContext.id, message);
+        this.parentContext.submitMessage(messageTypes_js_1.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.
+     */
+    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 === container_definitions_1.AttachState.Detached) {
+            // container is detached, only one client observes content,  no way to hit collisions with other clients.
+            return (0, runtime_utils_1.encodeCompactIdToString)(2 * this.contexts.size);
+        }
+        const id = this.parentContext.containerRuntime.generateDocumentUniqueId();
+        if (typeof id === "number") {
+            return (0, runtime_utils_1.encodeCompactIdToString)(2 * id + 1);
+        }
+        return id;
+    }
+    createDetachedDataStore(pkg, loadingGroupId) {
+        return this.createContext(this.createDataStoreId(), pkg, dataStoreContext_js_1.LocalDetachedFluidDataStoreContext, undefined, // props
+        loadingGroupId);
+    }
+    createDataStoreContext(pkg, props, loadingGroupId) {
+        return this.createContext(this.createDataStoreId(), pkg, dataStoreContext_js_1.LocalFluidDataStoreContext, props, loadingGroupId);
     }
-    _createFluidDataStoreContext(pkg, id, props, groupId) {
-        (0, core_utils_1.assert)(!id.includes("/"), 0x30d /* Id cannot contain slashes */);
-        const context = new dataStoreContext_1.LocalFluidDataStoreContext({
+    createContext(id, pkg, contextCtor, createProps, loadingGroupId) {
+        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: runtime_definitions_1.CreateSummarizerNodeSource.Local,
             }),
             makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(id),
             snapshotTree: undefined,
-            isRootDataStore: false,
-            createProps: props,
-            groupId,
+            createProps,
+            loadingGroupId,
+            channelToDataStoreFn: (channel) => (0, dataStore_js_1.channelToDataStore)(channel, id, this, (0, telemetry_utils_1.createChildLogger)({ logger: this.parentContext.logger })),
         });
         this.contexts.addUnbound(context);
         return context;
@@ -262,7 +452,20 @@ class DataStores {
     get disposed() {
         return this.disposeOnce.evaluated;
     }
-    resubmitDataStoreOp(envelope, localOpMetadata) {
+    reSubmit(type, content, localOpMetadata) {
+        switch (type) {
+            case messageTypes_js_1.ContainerMessageType.Attach:
+            case messageTypes_js_1.ContainerMessageType.Alias:
+                this.parentContext.submitMessage(type, content, localOpMetadata);
+                return;
+            case messageTypes_js_1.ContainerMessageType.FluidDataStoreOp:
+                return this.reSubmitChannelOp(type, content, localOpMetadata);
+            default:
+                (0, core_utils_1.assert)(false, "unknown op type");
+        }
+    }
+    reSubmitChannelOp(type, content, localOpMetadata) {
+        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.
@@ -273,9 +476,12 @@ class DataStores {
             });
         }
         (0, core_utils_1.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) {
+        (0, core_utils_1.assert)(type === messageTypes_js_1.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.
@@ -286,9 +492,23 @@ class DataStores {
             });
         }
         (0, core_utils_1.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 messageTypes_js_1.ContainerMessageType.Attach:
+                return this.applyStashedAttachOp(opContents.contents);
+            case messageTypes_js_1.ContainerMessageType.Alias:
+                return;
+            case messageTypes_js_1.ContainerMessageType.FluidDataStoreOp:
+                return this.applyStashedChannelChannelOp(opContents.contents);
+            default:
+                (0, core_utils_1.assert)(false, "unknon type of op");
+        }
+    }
+    async applyStashedChannelChannelOp(envelope) {
         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.
@@ -303,29 +523,61 @@ class DataStores {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         this.processAttachMessage({ contents: message }, false);
     }
-    processFluidDataStoreOp(message, local, localMessageMetadata, addedOutboundReference) {
-        const envelope = message.contents;
-        const transformed = { ...message, contents: envelope.contents };
-        const context = this.contexts.get(envelope.address);
+    process(message, local, localMessageMetadata, addedOutboundReference) {
+        switch (message.type) {
+            case messageTypes_js_1.ContainerMessageType.Attach:
+                this.processAttachMessage(message, local);
+                return;
+            case messageTypes_js_1.ContainerMessageType.Alias:
+                this.processAliasMessage(message, localMessageMetadata, local);
+                return;
+            case messageTypes_js_1.ContainerMessageType.FluidDataStoreOp: {
+                const envelope = message.contents;
+                const innerContents = envelope.contents;
+                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(index_js_1.detectOutboundRoutesViaDDSKey) !== true &&
+                    addedOutboundReference !== undefined) {
+                    // Notify GC of any outbound references that were added by this op.
+                    detectOutboundReferences(envelope.address, transformed.contents, addedOutboundReference);
+                }
+                break;
+            }
+            default:
+                (0, core_utils_1.assert)(false, 0x8e9 /* unreached */);
+        }
+    }
+    processChannelOp(address, message, local, localMessageMetadata) {
+        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;
         }
-        (0, core_utils_1.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(gc_1.detectOutboundRoutesViaDDSKey) !== true) {
-            // Notify GC of any outbound references that were added by this op.
-            detectOutboundReferences(envelope, addedOutboundReference);
+        if (context === undefined) {
+            // Former assert 0x162
+            throw telemetry_utils_1.DataProcessingError.create("No context for op", "processFluidDataStoreOp", message, {
+                local,
+                messageDetails: JSON.stringify({
+                    type: message.type,
+                    contentType: typeof message.contents,
+                }),
+                ...(0, telemetry_utils_1.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}`, message.timestamp, context.isLoaded ? context.packagePath : undefined);
+        this.gcNodeUpdated(`/${address}`, "Changed", message.timestamp, context.isLoaded ? context.packagePath : undefined);
     }
     async getDataStore(id, requestHeaderData) {
-        const headerData = { ...containerRuntime_1.defaultRuntimeHeaderData, ...requestHeaderData };
+        const headerData = { ...containerRuntime_js_1.defaultRuntimeHeaderData, ...requestHeaderData };
         if (this.checkAndLogIfDeleted(id, this.contexts.get(id), "Requested", "getDataStore", requestHeaderData)) {
             // The requested data store has been deleted by gc. Create a 404 response exception.
             const request = { url: id };
@@ -347,7 +599,7 @@ class DataStores {
         if (this.checkAndLogIfDeleted(id, this.contexts.get(id), "Requested", "getDataStoreIfAvailable", requestHeaderData)) {
             return undefined;
         }
-        const headerData = { ...containerRuntime_1.defaultRuntimeHeaderData, ...requestHeaderData };
+        const headerData = { ...containerRuntime_js_1.defaultRuntimeHeaderData, ...requestHeaderData };
         const context = await this.contexts.getBoundOrRemoted(id, headerData.wait);
         if (context === undefined) {
             return undefined;
@@ -376,7 +628,10 @@ 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.
@@ -409,7 +664,7 @@ class DataStores {
                         fluidDataStoreId,
                     }),
                     details: JSON.stringify({
-                        runtimeConnected: this.runtime.connected,
+                        runtimeConnected: this.parentContext.connected,
                         connected,
                     }),
                 }, error);
@@ -417,11 +672,10 @@ class DataStores {
         }
     }
     setAttachState(attachState) {
-        const eventName = attachState === container_definitions_1.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);
             }
         }
     }
@@ -449,7 +703,10 @@ class DataStores {
         }));
         return summaryBuilder.getSummaryTree();
     }
-    createSummary(telemetryContext) {
+    /**
+     * Create a summary. Used when attaching or serializing a detached container.
+     */
+    getAttachSummary(telemetryContext) {
         const builder = new runtime_utils_1.SummaryTreeBuilder();
         // Attaching graph of some stores can cause other stores to get bound too.
         // So keep taking summary until no new stores get bound.
@@ -469,8 +726,8 @@ class DataStores {
                 .map(([key, value]) => {
                 let dataStoreSummary;
                 if (value.isLoaded) {
-                    const snapshot = value.generateAttachMessage().snapshot;
-                    dataStoreSummary = (0, runtime_utils_1.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
@@ -494,8 +751,8 @@ class DataStores {
             (0, core_utils_1.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 datastore_1.FluidObjectHandle(context, id, this.runtime.IFluidHandleContext);
-                this.runtime.addedGCOutboundReference(this.containerRuntimeHandle, handle);
+                const handle = new datastore_1.FluidObjectHandle(context, id, this.parentContext.IFluidHandleContext);
+                this.parentContext.addedGCOutboundReference?.(this.containerRuntimeHandle, handle);
             }
         }
         this.dataStoresSinceLastGC = [];
@@ -554,26 +811,6 @@ class DataStores {
             context.updateUsedRoutes(usedDataStoreRoutes.get(contextId) ?? []);
         }
     }
-    /**
-     * 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.
-     */
-    updateUnusedRoutes(unusedRoutes) {
-        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];
-            (0, core_utils_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);
-        }
-    }
     /**
      * Delete data stores and its objects that are sweep ready.
      * @param sweepReadyDataStoreRoutes - The routes of data stores and its objects that are sweep ready and should
@@ -581,15 +818,12 @@ class DataStores {
      * @returns The routes of data stores and its objects that were deleted.
      */
     deleteSweepReadyNodes(sweepReadyDataStoreRoutes) {
-        // If sweep for data stores is not enabled, return empty list indicating nothing is deleted.
-        if (this.mc.config.getBoolean(gc_1.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;
             }
@@ -611,7 +845,7 @@ 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);
     }
@@ -675,17 +909,60 @@ class DataStores {
         // Data stores paths are of the format "/dataStoreId".
         // Sub data store paths are of the format "/dataStoreId/subPath/...".
         if (pathParts.length === 2) {
-            return gc_1.GCNodeType.DataStore;
+            return index_js_1.GCNodeType.DataStore;
         }
-        return gc_1.GCNodeType.SubDataStore;
+        return index_js_1.GCNodeType.SubDataStore;
+    }
+    internalId(maybeAlias) {
+        return this.aliases.get(maybeAlias) ?? maybeAlias;
+    }
+    async request(request) {
+        const requestParser = runtime_utils_1.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?.[exports.AllowTombstoneRequestHeaderKey] === "boolean") {
+            headerData.allowTombstone = request.headers[exports.AllowTombstoneRequestHeaderKey];
+        }
+        if (typeof request.headers?.[exports.AllowInactiveRequestHeaderKey] === "boolean") {
+            headerData.allowInactive = request.headers[exports.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 = (0, index_js_1.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.
+        (0, core_utils_1.assert)(subRequest.url.startsWith("/"), 0x126 /* "Expected createSubRequest url to include a leading slash" */);
+        return dataStore.request(subRequest);
     }
 }
-exports.DataStores = DataStores;
+exports.ChannelCollection = ChannelCollection;
 function getSummaryForDatastores(snapshot, metadata) {
     if (!snapshot) {
         return undefined;
     }
-    if ((0, summary_1.rootHasIsolatedChannels)(metadata)) {
+    if ((0, index_js_2.rootHasIsolatedChannels)(metadata)) {
         const datastoresSnapshot = snapshot.trees[runtime_definitions_1.channelsTreeName];
         (0, core_utils_1.assert)(!!datastoresSnapshot, 0x168 /* Expected tree in snapshot not found */);
         return datastoresSnapshot;
@@ -694,7 +971,7 @@ function getSummaryForDatastores(snapshot, metadata) {
         // back-compat: strip out all non-datastore paths before giving to DataStores object.
         const datastoresTrees = {};
         for (const [key, value] of Object.entries(snapshot.trees)) {
-            if (!summary_1.nonDataStorePaths.includes(key)) {
+            if (!index_js_2.nonDataStorePaths.includes(key)) {
                 datastoresTrees[key] = value;
             }
         }
@@ -710,7 +987,7 @@ exports.getSummaryForDatastores = getSummaryForDatastores;
  *
  * @internal
  */
-function detectOutboundReferences(envelope, addedOutboundReference) {
+function detectOutboundReferences(address, contents, addedOutboundReference) {
     // These will be built up as we traverse the envelope contents
     const outboundPaths = [];
     let ddsAddress;
@@ -731,11 +1008,34 @@ function detectOutboundReferences(envelope, addedOutboundReference) {
             }
         }
     }
-    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));
 }
 exports.detectOutboundReferences = detectOutboundReferences;
-//# sourceMappingURL=dataStores.js.map
+/** @internal */
+class ChannelCollectionFactory {
+    constructor(registryEntries, 
+    // ADO:7302 We need a better type here
+    provideEntryPoint, ctor) {
+        this.provideEntryPoint = provideEntryPoint;
+        this.ctor = ctor;
+        this.type = "ChannelCollectionChannel";
+        this.IFluidDataStoreRegistry = new dataStoreRegistry_js_1.FluidDataStoreRegistry(registryEntries);
+    }
+    get IFluidDataStoreFactory() {
+        return this;
+    }
+    async instantiateDataStore(context, _existing) {
+        const runtime = this.ctor(context.baseSnapshot, context, // parentContext
+        context.logger, () => { }, // gcNodeUpdated
+        (_nodePath) => false, // isDataStoreDeleted
+        new Map(), // aliasMap
+        this.provideEntryPoint);
+        return runtime;
+    }
+}
+exports.ChannelCollectionFactory = ChannelCollectionFactory;
+//# sourceMappingURL=channelCollection.js.map