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

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

@@ -4,34 +4,153 @@
  */
 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 { isDataStoreAliasMessage } from "./dataStore.mjs";
-import { GCNodeType, detectOutboundRoutesViaDDSKey, disableDatastoreSweepKey } from "./gc/index.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);
+        },
+        setChannelDirty: (address) => {
+            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, 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 +160,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,17 +183,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,
                     }),
-                    groupId: value.groupId,
+                    loadingGroupId: value.groupId,
                 });
             }
             else {
@@ -81,15 +204,14 @@ 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),
                     snapshotTree,
-                    isRootDataStore: undefined,
                 });
             }
             this.contexts.addBoundOrRemoted(dataStoreContext);
@@ -109,13 +231,45 @@ 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" */);
-            this.contexts.get(attachMessage.id)?.emit("attached");
+            this.contexts.get(attachMessage.id)?.setAttachState(AttachState.Attached);
             this.pendingAttach.delete(attachMessage.id);
             return;
         }
@@ -141,11 +295,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,
-            groupId: snapshotTree?.groupId,
-            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 ?? {
@@ -164,40 +318,52 @@ export class DataStores {
             });
         }
         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 FluidObjectHandle(context, aliasMessage.internalId, this.runtime.IFluidHandleContext);
-        this.runtime.addedGCOutboundReference(this.containerRuntimeHandle, handle);
-        this.aliasMap.set(aliasMessage.alias, context.id);
+        const handle = new 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 = 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) {
@@ -208,50 +374,72 @@ 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) {
-            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);
     }
-    createDetachedDataStoreCore(pkg, isRoot, id = uuid(), groupId) {
-        assert(!id.includes("/"), 0x30c /* Id cannot contain slashes */);
-        const context = new LocalDetachedFluidDataStoreContext({
-            id,
-            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;
+    submitAttachChannelOp(localContext) {
+        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.
+     */
+    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;
+    }
+    createDetachedDataStore(pkg, loadingGroupId) {
+        return this.createContext(this.createDataStoreId(), pkg, LocalDetachedFluidDataStoreContext, undefined, // props
+        loadingGroupId);
+    }
+    createDataStoreContext(pkg, props, loadingGroupId) {
+        return this.createContext(this.createDataStoreId(), pkg, LocalFluidDataStoreContext, props, loadingGroupId);
     }
-    _createFluidDataStoreContext(pkg, id, props, groupId) {
-        assert(!id.includes("/"), 0x30d /* Id cannot contain slashes */);
-        const context = new 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: CreateSummarizerNodeSource.Local,
             }),
             makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(id),
             snapshotTree: undefined,
-            isRootDataStore: false,
-            createProps: props,
-            groupId,
+            createProps,
+            loadingGroupId,
+            channelToDataStoreFn: (channel) => channelToDataStore(channel, id, this, createChildLogger({ logger: this.parentContext.logger })),
         });
         this.contexts.addUnbound(context);
         return context;
@@ -259,7 +447,20 @@ 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;
+            case ContainerMessageType.FluidDataStoreOp:
+                return this.reSubmitChannelOp(type, content, localOpMetadata);
+            default:
+                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.
@@ -270,9 +471,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.
@@ -283,9 +487,23 @@ 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;
+            case ContainerMessageType.FluidDataStoreOp:
+                return this.applyStashedChannelChannelOp(opContents.contents);
+            default:
+                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.
@@ -300,26 +518,58 @@ export 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 ContainerMessageType.Attach:
+                this.processAttachMessage(message, local);
+                return;
+            case ContainerMessageType.Alias:
+                this.processAliasMessage(message, localMessageMetadata, local);
+                return;
+            case 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(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 */);
+        }
+    }
+    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;
         }
-        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}`, message.timestamp, context.isLoaded ? context.packagePath : undefined);
+        this.gcNodeUpdated(`/${address}`, "Changed", message.timestamp, context.isLoaded ? context.packagePath : undefined);
     }
     async getDataStore(id, requestHeaderData) {
         const headerData = { ...defaultRuntimeHeaderData, ...requestHeaderData };
@@ -373,7 +623,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.
@@ -406,7 +659,7 @@ export class DataStores {
                         fluidDataStoreId,
                     }),
                     details: JSON.stringify({
-                        runtimeConnected: this.runtime.connected,
+                        runtimeConnected: this.parentContext.connected,
                         connected,
                     }),
                 }, error);
@@ -414,11 +667,10 @@ export class DataStores {
         }
     }
     setAttachState(attachState) {
-        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);
             }
         }
     }
@@ -446,7 +698,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.
@@ -466,8 +721,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
@@ -491,8 +746,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 = [];
@@ -551,26 +806,6 @@ export 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];
-            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
@@ -578,15 +813,12 @@ export 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(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;
             }
@@ -608,7 +840,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);
     }
@@ -676,6 +908,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,7 +980,7 @@ export function getSummaryForDatastores(snapshot, metadata) {
  *
  * @internal
  */
-export function detectOutboundReferences(envelope, addedOutboundReference) {
+export function detectOutboundReferences(address, contents, addedOutboundReference) {
     // These will be built up as we traverse the envelope contents
     const outboundPaths = [];
     let ddsAddress;
@@ -726,10 +1001,32 @@ export 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));
 }
-//# sourceMappingURL=dataStores.mjs.map
+/** @internal */
+export 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 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;
+    }
+}
+//# sourceMappingURL=channelCollection.js.map