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

package/lib/{container-runtime-untrimmed.d.mts → container-runtime-untrimmed.d.ts}

@@ -1,14 +1,16 @@
-import { assertIsStableId } from '@fluidframework/id-compressor';
+import { AliasResult } from '@fluidframework/runtime-definitions';
 import { AttachState } from '@fluidframework/container-definitions';
 import { ContainerWarning } from '@fluidframework/container-definitions';
+import { CreateChildSummarizerNodeFn } from '@fluidframework/runtime-definitions';
+import { CreateChildSummarizerNodeParam } from '@fluidframework/runtime-definitions';
 import { FluidDataStoreRegistryEntry } from '@fluidframework/runtime-definitions';
 import { FluidObject } from '@fluidframework/core-interfaces';
 import { FlushMode } from '@fluidframework/runtime-definitions';
-import { generateStableId } from '@fluidframework/id-compressor';
 import { IAudience } from '@fluidframework/container-definitions';
 import { IClientDetails } from '@fluidframework/protocol-definitions';
 import { IContainerContext } from '@fluidframework/container-definitions';
 import { IContainerRuntime } from '@fluidframework/container-runtime-definitions';
+import { IContainerRuntimeBase } from '@fluidframework/runtime-definitions';
 import { IContainerRuntimeEvents } from '@fluidframework/container-runtime-definitions';
 import { ICriticalContainerError } from '@fluidframework/container-definitions';
 import { IDataStore } from '@fluidframework/runtime-definitions';
@@ -16,17 +18,24 @@ import { IDeltaManager } from '@fluidframework/container-definitions';
 import { IDisposable } from '@fluidframework/core-interfaces';
 import { IDocumentMessage } from '@fluidframework/protocol-definitions';
 import { IDocumentStorageService } from '@fluidframework/driver-definitions';
+import { IEnvelope } from '@fluidframework/runtime-definitions';
 import { IEvent } from '@fluidframework/core-interfaces';
+import { IEvent as IEvent_2 } from '@fluidframework/common-definitions';
 import { IEventProvider } from '@fluidframework/core-interfaces';
+import { IFluidDataStoreChannel } from '@fluidframework/runtime-definitions';
+import { IFluidDataStoreContext } from '@fluidframework/runtime-definitions';
 import { IFluidDataStoreContextDetached } from '@fluidframework/runtime-definitions';
+import { IFluidDataStoreFactory } from '@fluidframework/runtime-definitions';
 import { IFluidDataStoreRegistry } from '@fluidframework/runtime-definitions';
 import { IFluidHandle } from '@fluidframework/core-interfaces';
 import { IFluidHandleContext } from '@fluidframework/core-interfaces';
+import { IFluidParentContext } from '@fluidframework/runtime-definitions';
 import { IGarbageCollectionData } from '@fluidframework/runtime-definitions';
+import { IGarbageCollectionDetailsBase } from '@fluidframework/runtime-definitions';
 import { IGetPendingLocalStateProps } from '@fluidframework/container-definitions';
 import type { IIdCompressor } from '@fluidframework/id-compressor';
 import type { IIdCompressorCore } from '@fluidframework/id-compressor';
-import { ILoaderOptions } from '@fluidframework/container-definitions';
+import { IInboundSignalMessage } from '@fluidframework/runtime-definitions';
 import { IProvideFluidHandleContext } from '@fluidframework/core-interfaces';
 import { IQuorumClients } from '@fluidframework/protocol-definitions';
 import { IRequest } from '@fluidframework/core-interfaces';
@@ -34,17 +43,22 @@ import { IResponse } from '@fluidframework/core-interfaces';
 import { IRuntime } from '@fluidframework/container-definitions';
 import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
 import { ISignalMessage } from '@fluidframework/protocol-definitions';
-import { isStableId } from '@fluidframework/id-compressor';
+import { ISnapshotTree } from '@fluidframework/protocol-definitions';
+import { ISummarizeResult } from '@fluidframework/runtime-definitions';
+import { ISummarizerNodeWithGC } from '@fluidframework/runtime-definitions';
 import { ISummaryAck } from '@fluidframework/protocol-definitions';
 import { ISummaryContent } from '@fluidframework/protocol-definitions';
 import { ISummaryNack } from '@fluidframework/protocol-definitions';
 import { ISummaryStats } from '@fluidframework/runtime-definitions';
 import { ISummaryTree } from '@fluidframework/protocol-definitions';
 import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
 import { ITelemetryContext } from '@fluidframework/runtime-definitions';
 import { ITelemetryLoggerExt } from '@fluidframework/telemetry-utils';
 import { MessageType } from '@fluidframework/protocol-definitions';
+import { MonitoringContext } from '@fluidframework/telemetry-utils';
 import { NamedFluidDataStoreRegistryEntries } from '@fluidframework/runtime-definitions';
+import { SummarizeInternalFn } from '@fluidframework/runtime-definitions';
 import { TypedEventEmitter } from '@fluid-internal/client-utils';
 
 /**
@@ -66,7 +80,178 @@ export declare const AllowInactiveRequestHeaderKey = "allowInactive";
  */
 export declare const AllowTombstoneRequestHeaderKey = "allowTombstone";
 
-export { assertIsStableId }
+/**
+ * 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 declare class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
+    protected readonly baseSnapshot: ISnapshotTree | undefined;
+    readonly parentContext: IFluidParentContext;
+    private readonly gcNodeUpdated;
+    private readonly isDataStoreDeleted;
+    private readonly aliasMap;
+    private readonly pendingAttach;
+    readonly attachOpFiredForDataStore: Set<string>;
+    protected readonly mc: MonitoringContext;
+    private readonly disposeOnce;
+    readonly entryPoint: IFluidHandle<FluidObject>;
+    readonly containerLoadStats: {
+        readonly containerLoadDataStoreCount: number;
+        readonly referencedDataStoreCount: number;
+    };
+    private dataStoresSinceLastGC;
+    private readonly containerRuntimeHandle;
+    private readonly pendingAliasMap;
+    protected readonly contexts: DataStoreContexts;
+    constructor(baseSnapshot: ISnapshotTree | undefined, parentContext: IFluidParentContext, baseLogger: ITelemetryBaseLogger, gcNodeUpdated: (nodePath: string, reason: "Loaded" | "Changed", timestampMs?: number, packagePath?: readonly string[], request?: IRequest, headerData?: RuntimeHeaderData) => void, isDataStoreDeleted: (nodePath: string) => boolean, aliasMap: Map<string, string>, provideEntryPoint: (runtime: ChannelCollection) => Promise<FluidObject>);
+    get aliases(): ReadonlyMap<string, string>;
+    get pendingAliases(): Map<string, Promise<AliasResult>>;
+    waitIfPendingAlias(maybeAlias: string): Promise<AliasResult>;
+    /** For sampling. Only log once per container */
+    private shouldSendAttachLog;
+    protected wrapContextForInnerChannel(id: string): IFluidParentContext;
+    /**
+     * 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(): void;
+    private processAttachMessage;
+    private processAliasMessage;
+    processAliasMessageCore(internalId: string, alias: string): boolean;
+    private alreadyProcessed;
+    /** Package up the context's attach summary etc into an IAttachMessage */
+    private generateAttachMessage;
+    /**
+     * Make the data store locally visible in the container graph by moving the data store context from unbound to
+     * bound list and submitting the attach message. This data store can now be reached from the root.
+     * @param id - The id of the data store context to make visible.
+     */
+    private makeDataStoreLocallyVisible;
+    protected submitAttachChannelOp(localContext: LocalFluidDataStoreContext): void;
+    /**
+     * Generate compact internal DataStore ID.
+     *
+     * A note about namespace and name collisions:
+     * This code assumes that that's the only way to generate internal IDs, and that it's Ok for this namespace to overlap with
+     * user-provided alias names namespace.
+     * There are two scenarios where it could cause trouble:
+     * 1) Old files, where (already removed) CreateRoot*DataStore*() API was used, and thus internal name of data store
+     * was provided by user. Such files may experience name collision with future data stores that receive a name generated
+     * by this function.
+     * 2) Much less likely, but if it happen that internal ID (generated by this function) is exactly the same as alias name
+     * that user might use in the future, them ContainerRuntime.getAliasedDataStoreEntryPoint() or
+     * ContainerRuntime.getDataStoreFromRequest() could return a data store with internalID matching user request, even though
+     * user expected some other data store (that would receive alias later).
+     * Please note that above mentioned functions have the implementation they have (allowing #2) due to #1.
+     */
+    protected createDataStoreId(): string;
+    createDetachedDataStore(pkg: Readonly<string[]>, loadingGroupId?: string): IFluidDataStoreContextDetached;
+    createDataStoreContext(pkg: Readonly<string[]>, props?: any, loadingGroupId?: string): IFluidDataStoreContextInternal;
+    protected createContext<T extends LocalFluidDataStoreContext>(id: string, pkg: Readonly<string[]>, contextCtor: new (props: ILocalDetachedFluidDataStoreContextProps) => T, createProps?: any, loadingGroupId?: string): T;
+    get disposed(): boolean;
+    readonly dispose: () => void;
+    reSubmit(type: string, content: any, localOpMetadata: unknown): void;
+    protected reSubmitChannelOp(type: string, content: any, localOpMetadata: unknown): void;
+    rollback(type: string, content: any, localOpMetadata: unknown): void;
+    applyStashedOp(content: unknown): Promise<unknown>;
+    protected applyStashedChannelChannelOp(envelope: IEnvelope): Promise<unknown>;
+    private applyStashedAttachOp;
+    process(message: ISequencedDocumentMessage, local: boolean, localMessageMetadata: unknown, addedOutboundReference?: (fromNodePath: string, toNodePath: string) => void): void;
+    protected processChannelOp(address: string, message: ISequencedDocumentMessage, local: boolean, localMessageMetadata: unknown): void;
+    getDataStore(id: string, requestHeaderData: RuntimeHeaderData): Promise<IFluidDataStoreContextInternal>;
+    /**
+     * Returns the data store requested with the given id if available. Otherwise, returns undefined.
+     */
+    getDataStoreIfAvailable(id: string, requestHeaderData: RuntimeHeaderData): Promise<IFluidDataStoreContextInternal | undefined>;
+    /**
+     * Checks if the data store has been deleted by GC. If so, log an error.
+     * @param id - The data store's id.
+     * @param context - The data store context.
+     * @param callSite - The function name this is called from.
+     * @param requestHeaderData - The request header information to log if the data store is deleted.
+     * @returns true if the data store is deleted. Otherwise, returns false.
+     */
+    private checkAndLogIfDeleted;
+    processSignal(messageArg: IInboundSignalMessage, local: boolean): void;
+    setConnectionState(connected: boolean, clientId?: string): void;
+    setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
+    get size(): number;
+    summarize(fullTree: boolean, trackState: boolean, telemetryContext?: ITelemetryContext): Promise<ISummaryTreeWithStats>;
+    /**
+     * Create a summary. Used when attaching or serializing a detached container.
+     */
+    getAttachSummary(telemetryContext?: ITelemetryContext): ISummaryTreeWithStats;
+    /**
+     * Before GC runs, called by the garbage collector to update any pending GC state.
+     * The garbage collector needs to know all outbound references that are added. Since root data stores are not
+     * explicitly marked as referenced, notify GC of new root data stores that were added since the last GC run.
+     */
+    updateStateBeforeGC(): Promise<void>;
+    /**
+     * Generates data used for garbage collection. It does the following:
+     *
+     * 1. Calls into each child data store context to get its GC data.
+     *
+     * 2. Prefixes the child context's id to the GC nodes in the child's GC data. This makes sure that the node can be
+     * identified as belonging to the child.
+     *
+     * 3. Adds a GC node for this channel to the nodes received from the children. All these nodes together represent
+     * the GC data of this channel.
+     *
+     * @param fullGC - true to bypass optimizations and force full generation of GC data.
+     */
+    getGCData(fullGC?: boolean): Promise<IGarbageCollectionData>;
+    /**
+     * After GC has run, called to notify this Container's data stores of routes that are used in it.
+     * @param usedRoutes - The routes that are used in all data stores in this Container.
+     */
+    updateUsedRoutes(usedRoutes: readonly string[]): void;
+    /**
+     * 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
+     * be deleted.
+     * @returns The routes of data stores and its objects that were deleted.
+     */
+    deleteSweepReadyNodes(sweepReadyDataStoreRoutes: readonly string[]): readonly string[];
+    /**
+     * This is called to update objects whose routes are tombstones.
+     *
+     * A Tombstoned object has been unreferenced long enough that GC knows it won't be referenced again.
+     * Tombstoned objects are eventually deleted by GC.
+     *
+     * @param tombstonedRoutes - The routes that are tombstones in all data stores in this Container.
+     */
+    updateTombstonedRoutes(tombstonedRoutes: readonly string[]): void;
+    /**
+     * Returns the outbound routes of this channel. Only root data stores are considered referenced and their paths are
+     * part of outbound routes.
+     */
+    private getOutboundRoutes;
+    /**
+     * Called by GC to retrieve the package path of a data store node with the given path.
+     */
+    getDataStorePackagePath(nodePath: string): Promise<readonly string[] | undefined>;
+    /**
+     * Called by GC to determine if a node is for a data store or for an object within a data store (for e.g. DDS).
+     * @returns the GC node type if the node belongs to a data store or object within data store, undefined otherwise.
+     */
+    getGCNodeType(nodePath: string): GCNodeType | undefined;
+    internalId(maybeAlias: string): string;
+    request(request: IRequest): Promise<IResponse>;
+}
+
+/** @internal */
+export declare class ChannelCollectionFactory<T extends ChannelCollection = ChannelCollection> implements IFluidDataStoreFactory {
+    private readonly provideEntryPoint;
+    private readonly ctor;
+    readonly type = "ChannelCollectionChannel";
+    IFluidDataStoreRegistry: IFluidDataStoreRegistry;
+    constructor(registryEntries: NamedFluidDataStoreRegistryEntries, provideEntryPoint: (runtime: IFluidDataStoreChannel) => Promise<FluidObject>, ctor: (...args: ConstructorParameters<typeof ChannelCollection>) => T);
+    get IFluidDataStoreFactory(): this;
+    instantiateDataStore(context: IFluidDataStoreContext, _existing: boolean): Promise<IFluidDataStoreChannel>;
+}
 
 /**
  * How should an older client handle an unrecognized remote op type?
@@ -117,10 +302,13 @@ export declare enum ContainerMessageType {
  */
 export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents & ISummarizerEvents> implements IContainerRuntime, IRuntime, ISummarizerRuntime, ISummarizerInternalsProvider, IProvideFluidHandleContext {
     private readonly registry;
+    private readonly metadata;
     private readonly runtimeOptions;
     private readonly containerScope;
     readonly logger: ITelemetryLoggerExt;
     private readonly _storage;
+    private readonly createIdCompressor;
+    private readonly idCompressorMode;
     private readonly requestHandler?;
     private readonly summaryConfiguration;
     /**
@@ -149,12 +337,13 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
         requestHandler?: (request: IRequest, runtime: IContainerRuntime) => Promise<IResponse>;
         provideEntryPoint: (containerRuntime: IContainerRuntime) => Promise<FluidObject>;
     }): Promise<ContainerRuntime>;
-    readonly options: ILoaderOptions;
+    readonly options: Record<string | number, any>;
     private imminentClosure;
     private readonly _getClientId;
     get clientId(): string | undefined;
     readonly clientDetails: IClientDetails;
     get storage(): IDocumentStorageService;
+    get containerRuntime(): this;
     private readonly submitFn;
     /**
      * Although current IContainerContext guarantees submitBatchFn, it is not available on older loaders.
@@ -169,7 +358,26 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
     get IFluidDataStoreRegistry(): IFluidDataStoreRegistry;
     private readonly _getAttachState;
     get attachState(): AttachState;
-    idCompressor: (IIdCompressor & IIdCompressorCore) | undefined;
+    private _idCompressor;
+    private pendingIdCompressorOps;
+    private readonly skipSavedCompressorOps;
+    /**
+     * See IContainerRuntimeBase.idCompressor() for details.
+     */
+    get idCompressor(): (IIdCompressor & IIdCompressorCore) | undefined;
+    /**
+     * True if we have ID compressor loading in-flight (async operation). Useful only for
+     * this.idCompressorMode === "delayed" mode
+     */
+    protected compressorLoadInitiated: boolean;
+    /**
+     * See IContainerRuntimeBase.generateDocumentUniqueId() for details.
+     */
+    generateDocumentUniqueId(): string | (number & {
+        readonly SessionUnique: "cea55054-6b82-4cbf-ad19-1fa645ea3b3e";
+    } & {
+        readonly OpNormalized: "9209432d-a959-4df7-b2ad-767ead4dbcae";
+    });
     get IFluidHandleContext(): IFluidHandleContext;
     private readonly handleContext;
     /**
@@ -252,15 +460,13 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
     private readonly pendingStateManager;
     private readonly outbox;
     private readonly garbageCollector;
-    private readonly dataStores;
+    private readonly channelCollection;
     private readonly remoteMessageProcessor;
     /** The last message processed at the time of the last summary. */
     private messageAtLastSummary;
     private get summarizer();
     private readonly summariesDisabled;
     private isSummariesDisabled;
-    private readonly heuristicsDisabled;
-    private isHeuristicsDisabled;
     private readonly maxOpsSinceLastSummary;
     private getMaxOpsSinceLastSummary;
     private readonly initialSummarizerDelayMs;
@@ -280,10 +486,6 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * ! Note: should not be used for anything other than telemetry and is not considered a stable GUID
      */
     private readonly telemetryDocumentId;
-    /**
-     * If true, the runtime has access to an IdCompressor
-     */
-    private readonly idCompressorEnabled;
     /**
      * Whether this client is the summarizer client itself (type is summarizerClientType)
      */
@@ -292,13 +494,41 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * The id of the version used to initially load this runtime, or undefined if it's newly created.
      */
     private readonly loadedFromVersionId;
+    /**
+     * It a cache for holding mapping for loading groupIds with its snapshot from the service. Add expiry policy of 1 minute.
+     * Starting with 1 min and based on recorded usage we can tweak it later on.
+     */
+    private readonly snapshotCacheForLoadingGroupIds;
     /***/
-    protected constructor(context: IContainerContext, registry: IFluidDataStoreRegistry, metadata: IContainerRuntimeMetadata | undefined, electedSummarizerData: ISerializedElection | undefined, chunks: [string, string[]][], dataStoreAliasMap: [string, string][], runtimeOptions: Readonly<Required<IContainerRuntimeOptions>>, containerScope: FluidObject, logger: ITelemetryLoggerExt, existing: boolean, blobManagerSnapshot: IBlobManagerLoadInfo, _storage: IDocumentStorageService, idCompressor: (IIdCompressor & IIdCompressorCore) | undefined, provideEntryPoint: (containerRuntime: IContainerRuntime) => Promise<FluidObject>, requestHandler?: ((request: IRequest, runtime: IContainerRuntime) => Promise<IResponse>) | undefined, summaryConfiguration?: ISummaryConfiguration);
+    protected constructor(context: IContainerContext, registry: IFluidDataStoreRegistry, metadata: IContainerRuntimeMetadata | undefined, electedSummarizerData: ISerializedElection | undefined, chunks: [string, string[]][], dataStoreAliasMap: [string, string][], runtimeOptions: Readonly<Required<IContainerRuntimeOptions>>, containerScope: FluidObject, logger: ITelemetryLoggerExt, existing: boolean, blobManagerSnapshot: IBlobManagerLoadInfo, _storage: IDocumentStorageService, createIdCompressor: () => Promise<IIdCompressor & IIdCompressorCore>, idCompressorMode: IdCompressorMode, provideEntryPoint: (containerRuntime: IContainerRuntime) => Promise<FluidObject>, requestHandler?: ((request: IRequest, runtime: IContainerRuntime) => Promise<IResponse>) | undefined, summaryConfiguration?: ISummaryConfiguration);
+    getCreateChildSummarizerNodeFn(id: string, createParam: CreateChildSummarizerNodeParam): (summarizeInternal: SummarizeInternalFn, getGCDataFn: (fullGC?: boolean) => Promise<IGarbageCollectionData>) => ISummarizerNodeWithGC;
+    deleteChildSummarizerNode(id: string): void;
+    makeLocallyVisible(): void;
+    setChannelDirty(address: string): void;
     /**
      * Initializes the state from the base snapshot this container runtime loaded from.
      */
     private initializeBaseState;
     dispose(error?: Error): void;
+    /**
+     * Api to fetch the snapshot from the service for a loadingGroupIds.
+     * @param loadingGroupIds - LoadingGroupId for which the snapshot is asked for.
+     * @param pathParts - Parts of the path, which we want to extract from the snapshot tree.
+     * @returns - snapshotTree and the sequence number of the snapshot.
+     */
+    getSnapshotForLoadingGroupId(loadingGroupIds: string[], pathParts: string[]): Promise<{
+        snapshotTree: ISnapshotTree;
+        sequenceNumber: number;
+    }>;
+    /**
+     * Api to find a snapshot tree inside a bigger snapshot tree based on the path in the pathParts array.
+     * @param snapshotTree - snapshot tree to look into.
+     * @param pathParts - Part of the path, which we want to extract from the snapshot tree.
+     * @param hasIsolatedChannels - whether the channels are present inside ".channels" subtree. Older
+     * snapshots will not have trees inside ".channels", so check that.
+     * @returns - requested snapshot tree based on the path parts.
+     */
+    private getSnapshotTreeForPath;
     /**
      * Notifies this object about the request made to the container.
      * @param request - Request made to the handler.
@@ -316,7 +546,6 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
     getEntryPoint(): Promise<FluidObject>;
     private readonly entryPoint;
     private internalId;
-    private getDataStoreFromRequest;
     /** Adds the container's metadata to the given summary tree. */
     private addMetadataToSummary;
     protected addContainerStateToSummary(summaryTree: ISummaryTreeWithStats, fullTree: boolean, trackState: boolean, telemetryContext?: ITelemetryContext): void;
@@ -355,6 +584,9 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * This method is expected to be called at the end of a batch.
      */
     private flush;
+    /**
+     * {@inheritDoc @fluidframework/runtime-definitions#IContainerRuntimeBase.orderSequentially}
+     */
     orderSequentially<T>(callback: () => T): T;
     /**
      * Returns the aliased data store's entryPoint, given the alias.
@@ -363,13 +595,12 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * Returns undefined if no data store has been assigned the given alias.
      */
     getAliasedDataStoreEntryPoint(alias: string): Promise<IFluidHandle<FluidObject> | undefined>;
-    createDetachedRootDataStore(pkg: Readonly<string[]>, rootDataStoreId: string): IFluidDataStoreContextDetached;
-    createDetachedDataStore(pkg: Readonly<string[]>): IFluidDataStoreContextDetached;
-    createDataStore(pkg: string | string[]): Promise<IDataStore>;
+    createDetachedDataStore(pkg: Readonly<string[]>, loadingGroupId?: string): IFluidDataStoreContextDetached;
+    createDataStore(pkg: Readonly<string | string[]>, loadingGroupId?: string): Promise<IDataStore>;
     /**
      * @deprecated 0.16 Issue #1537, #3631
      */
-    _createDataStoreWithProps(pkg: string | string[], props?: any, id?: string): Promise<IDataStore>;
+    _createDataStoreWithProps(pkg: Readonly<string | string[]>, props?: any): Promise<IDataStore>;
     private canSendOps;
     /**
      * Are we in the middle of batching ops together?
@@ -393,13 +624,6 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * @param targetClientId - When specified, the signal is only sent to the provided client id.
      */
     submitSignal(type: string, content: any, targetClientId?: string): void;
-    /**
-     * Submits the signal to be sent to other clients.
-     * @param type - Type of the signal.
-     * @param content - Content of the signal.
-     * @param targetClientId - When specified, the signal is only sent to the provided client id.
-     */
-    submitDataStoreSignal(address: string, type: string, content: any, targetClientId?: string): void;
     setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
     /**
      * Create a summary. Used when attaching or serializing a detached container.
@@ -449,15 +673,6 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * @see IGarbageCollectionRuntime.updateUsedRoutes
      */
     updateUsedRoutes(usedRoutes: readonly string[]): void;
-    /**
-     * This is called to update objects whose routes are unused.
-     * @param unusedRoutes - Data store and attachment blob routes that are unused in this Container.
-     */
-    updateUnusedRoutes(unusedRoutes: readonly string[]): void;
-    /**
-     * @deprecated Replaced by deleteSweepReadyNodes.
-     */
-    deleteUnusedNodes(unusedRoutes: readonly string[]): string[];
     /**
      * After GC has run and identified nodes that are sweep ready, this is called to delete the sweep ready nodes.
      * @param sweepReadyRoutes - The routes of nodes that are sweep ready and should be deleted.
@@ -516,7 +731,11 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * @param srcHandle - The handle of the node that added the reference.
      * @param outboundHandle - The handle of the outbound node that is referenced.
      */
-    addedGCOutboundReference(srcHandle: IFluidHandle, outboundHandle: IFluidHandle): void;
+    addedGCOutboundReference(srcHandle: {
+        absolutePath: string;
+    }, outboundHandle: {
+        absolutePath: string;
+    }): void;
     /**
      * Generates the summary tree, uploads it to storage, and then submits the summarize op.
      * This is intended to be called by the summarizer, since it is the implementation of
@@ -540,10 +759,9 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
     private get pendingMessagesCount();
     private hasPendingMessages;
     private updateDocumentDirtyState;
-    submitDataStoreOp(id: string, contents: any, localOpMetadata?: unknown): void;
-    submitDataStoreAliasOp(contents: any, localOpMetadata: unknown): void;
+    submitMessage(type: ContainerMessageType.FluidDataStoreOp | ContainerMessageType.Alias | ContainerMessageType.Attach, contents: any, localOpMetadata?: unknown): void;
     uploadBlob(blob: ArrayBufferLike, signal?: AbortSignal): Promise<IFluidHandle<ArrayBufferLike>>;
-    private maybeSubmitIdAllocationOp;
+    private submitIdAllocationOpIfNeeded;
     private submit;
     private scheduleFlush;
     private submitSummaryMessage;
@@ -580,7 +798,7 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * overridden via options.
      */
     private fetchLatestSnapshotFromStorage;
-    getPendingLocalState(props?: IGetPendingLocalStateProps): Promise<unknown>;
+    getPendingLocalState(props?: IGetPendingLocalStateProps): unknown;
     summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults;
     enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult;
     /**
@@ -611,11 +829,77 @@ export declare interface ContainerRuntimeMessage {
     compatDetails?: IContainerRuntimeMessageCompatDetails;
 }
 
+/** @internal */
+export declare class DataStoreContexts implements Iterable<[string, FluidDataStoreContext]>, IDisposable {
+    private readonly notBoundContexts;
+    /** Attached and loaded context proxies */
+    private readonly _contexts;
+    /**
+     * List of pending context waiting either to be bound or to arrive from another client.
+     * This covers the case where a local context has been created but not yet bound,
+     * or the case where a client knows a store will exist and is waiting on its creation,
+     * so that a caller may await the deferred's promise until such a time as the context is fully ready.
+     * This is a superset of _contexts, since contexts remain here once the Deferred resolves.
+     */
+    private readonly deferredContexts;
+    private readonly disposeOnce;
+    private readonly _logger;
+    constructor(baseLogger: ITelemetryBaseLogger);
+    [Symbol.iterator](): Iterator<[string, FluidDataStoreContext]>;
+    get size(): number;
+    get disposed(): boolean;
+    readonly dispose: () => void;
+    notBoundLength(): number;
+    isNotBound(id: string): boolean;
+    has(id: string): boolean;
+    get(id: string): FluidDataStoreContext | undefined;
+    delete(id: string): boolean;
+    /**
+     * Return the unbound local context with the given id,
+     * or undefined if it's not found or not unbound.
+     */
+    getUnbound(id: string): LocalFluidDataStoreContext | undefined;
+    /**
+     * Add the given context, marking it as to-be-bound
+     */
+    addUnbound(context: LocalFluidDataStoreContext): void;
+    /**
+     * Get the context with the given id, once it exists locally and is attached.
+     * e.g. If created locally, it must be bound, or if created remotely then it's fine as soon as it's sync'd in.
+     * @param id - The id of the context to get
+     * @param wait - If false, return undefined if the context isn't present and ready now. Otherwise, wait for it.
+     */
+    getBoundOrRemoted(id: string, wait: boolean): Promise<FluidDataStoreContext | undefined>;
+    private ensureDeferred;
+    /**
+     * Update this context as bound
+     */
+    bind(id: string): void;
+    /**
+     * Triggers the deferred to resolve, indicating the context is not local-only
+     * @param id - The id of the context to resolve to
+     */
+    private resolveDeferred;
+    /**
+     * Add the given context, marking it as not local-only.
+     * This could be because it's a local context that's been bound, or because it's a remote context.
+     * @param context - The context to add
+     */
+    addBoundOrRemoted(context: FluidDataStoreContext): void;
+}
+
 /**
  * @alpha
  */
 export declare const DefaultSummaryConfiguration: ISummaryConfiguration;
 
+/**
+ * Traverse this op's contents and detect any outbound routes that were added by this op.
+ *
+ * @internal
+ */
+export declare function detectOutboundReferences(address: string, contents: unknown, addedOutboundReference: (fromNodePath: string, toNodePath: string) => void): void;
+
 /**
  * @alpha
  */
@@ -643,6 +927,246 @@ export declare type EnqueueSummarizeResult = (ISummarizeResults & {
     readonly overridden?: undefined;
 };
 
+/**
+ * Represents the context for the store. This context is passed to the store runtime.
+ * @internal
+ */
+export declare abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidDataStoreContextEvents> implements IFluidDataStoreContextInternal, IFluidParentContext, IDisposable {
+    private readonly existing;
+    readonly isLocalDataStore: boolean;
+    private readonly makeLocallyVisibleFn;
+    get packagePath(): readonly string[];
+    get options(): Record<string | number, any>;
+    get clientId(): string | undefined;
+    get clientDetails(): IClientDetails;
+    get logger(): ITelemetryBaseLogger;
+    get deltaManager(): IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    get connected(): boolean;
+    get IFluidHandleContext(): IFluidHandleContext;
+    get containerRuntime(): IContainerRuntimeBase;
+    ensureNoDataModelChanges<T>(callback: () => T): T;
+    get isLoaded(): boolean;
+    get baseSnapshot(): ISnapshotTree | undefined;
+    get idCompressor(): IIdCompressor | undefined;
+    private _disposed;
+    get disposed(): boolean;
+    /**
+     * A Tombstoned object has been unreferenced long enough that GC knows it won't be referenced again.
+     * Tombstoned objects are eventually deleted by GC.
+     */
+    private _tombstoned;
+    get tombstoned(): boolean;
+    /** If true, throw an error when a tombstone data store is used. */
+    readonly gcThrowOnTombstoneUsage: boolean;
+    readonly gcTombstoneEnforcementAllowed: boolean;
+    /** If true, this means that this data store context and its children have been removed from the runtime */
+    protected deleted: boolean;
+    get attachState(): AttachState;
+    get IFluidDataStoreRegistry(): IFluidDataStoreRegistry | undefined;
+    private baseSnapshotSequenceNumber;
+    /**
+     * A datastore is considered as root if it
+     * 1. is root in memory - see isInMemoryRoot
+     * 2. is root as part of the base snapshot that the datastore loaded from
+     * @returns whether a datastore is root
+     */
+    isRoot(): Promise<boolean>;
+    /**
+     * There are 3 states where isInMemoryRoot needs to be true
+     * 1. when a datastore becomes aliased. This can happen for both remote and local datastores
+     * 2. when a datastore is created locally as root
+     * 3. when a datastore is created locally as root and is rehydrated
+     * @returns whether a datastore is root in memory
+     */
+    protected isInMemoryRoot(): boolean;
+    protected registry: IFluidDataStoreRegistry | undefined;
+    protected detachedRuntimeCreation: boolean;
+    protected channel: IFluidDataStoreChannel | undefined;
+    private loaded;
+    protected pending: ISequencedDocumentMessage[] | undefined;
+    protected channelP: Promise<IFluidDataStoreChannel> | undefined;
+    protected _baseSnapshot: ISnapshotTree | undefined;
+    protected _attachState: AttachState;
+    private _isInMemoryRoot;
+    protected readonly summarizerNode: ISummarizerNodeWithGC;
+    protected readonly mc: MonitoringContext;
+    private readonly thresholdOpsCounter;
+    private static readonly pendingOpsCountThreshold;
+    /**
+     * If the summarizer makes local changes, a telemetry event is logged. This has the potential to be very noisy.
+     * So, adding a count of how many telemetry events are logged per data store context. This can be
+     * controlled via feature flags.
+     */
+    private localChangesTelemetryCount;
+    private lastUsedRoutes;
+    readonly id: string;
+    private readonly _containerRuntime;
+    private readonly parentContext;
+    readonly storage: IDocumentStorageService;
+    readonly scope: FluidObject;
+    readonly loadingGroupId: string | undefined;
+    protected pkg?: readonly string[];
+    constructor(props: IFluidDataStoreContextProps, existing: boolean, isLocalDataStore: boolean, makeLocallyVisibleFn: () => void);
+    dispose(): void;
+    /**
+     * When delete is called, that means that the data store is permanently removed from the runtime, and will not show up in future summaries
+     * This function is called to prevent ops from being generated from this data store once it has been deleted. Furthermore, this data store
+     * should not receive any ops/signals.
+     */
+    delete(): void;
+    setTombstone(tombstone: boolean): void;
+    abstract setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
+    private rejectDeferredRealize;
+    realize(): Promise<IFluidDataStoreChannel>;
+    protected factoryFromPackagePath(): Promise<IFluidDataStoreFactory>;
+    private realizeCore;
+    /**
+     * Notifies this object about changes in the connection state.
+     * @param value - New connection state.
+     * @param clientId - ID of the client. Its old ID when in disconnected state and
+     * its new client ID when we are connecting or connected.
+     */
+    setConnectionState(connected: boolean, clientId?: string): void;
+    process(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    processSignal(message: IInboundSignalMessage, local: boolean): void;
+    getQuorum(): IQuorumClients;
+    getAudience(): IAudience;
+    /**
+     * Returns a summary at the current sequence number.
+     * @param fullTree - true to bypass optimizations and force a full summary tree
+     * @param trackState - This tells whether we should track state from this summary.
+     * @param telemetryContext - summary data passed through the layers for telemetry purposes
+     */
+    summarize(fullTree?: boolean, trackState?: boolean, telemetryContext?: ITelemetryContext): Promise<ISummarizeResult>;
+    private summarizeInternal;
+    /**
+     * Returns the data used for garbage collection. This includes a list of GC nodes that represent this data store
+     * including any of its child channel contexts. Each node has a set of outbound routes to other GC nodes in the
+     * document.
+     * If there is no new data in this data store since the last summary, previous GC data is used.
+     * If there is new data, the GC data is generated again (by calling getGCDataInternal).
+     * @param fullGC - true to bypass optimizations and force full generation of GC data.
+     */
+    getGCData(fullGC?: boolean): Promise<IGarbageCollectionData>;
+    /**
+     * Generates data used for garbage collection. This is called when there is new data since last summary. It
+     * realizes the data store and calls into each channel context to get its GC data.
+     * @param fullGC - true to bypass optimizations and force full generation of GC data.
+     */
+    private getGCDataInternal;
+    /**
+     * After GC has run, called to notify the data store of routes used in it. These are used for the following:
+     *
+     * 1. To identify if this data store is being referenced in the document or not.
+     *
+     * 2. To determine if it needs to re-summarize in case used routes changed since last summary.
+     *
+     * 3. These are added to the summary generated by the data store.
+     *
+     * 4. To notify child contexts of their used routes. This is done immediately if the data store is loaded.
+     * Else, it is done when realizing the data store.
+     *
+     * 5. To update the timestamp when this data store or any children are marked as unreferenced.
+     *
+     * @param usedRoutes - The routes that are used in this data store.
+     */
+    updateUsedRoutes(usedRoutes: string[]): void;
+    /**
+     * @deprecated There is no replacement for this, its functionality is no longer needed at this layer.
+     * It will be removed in a future release, sometime after 2.0.0-internal.8.0.0
+     *
+     * Similar capability is exposed with from/to string paths instead of handles via @see addedGCOutboundRoute
+     *
+     * Called when a new outbound reference is added to another node. This is used by garbage collection to identify
+     * all references added in the system.
+     * @param srcHandle - The handle of the node that added the reference.
+     * @param outboundHandle - The handle of the outbound node that is referenced.
+     */
+    addedGCOutboundReference(srcHandle: IFluidHandle, outboundHandle: IFluidHandle): void;
+    /**
+     * (Same as @see addedGCOutboundReference, but with string paths instead of handles)
+     *
+     * Called when a new outbound reference is added to another node. This is used by garbage collection to identify
+     * all references added in the system.
+     *
+     * @param fromPath - The absolute path of the node that added the reference.
+     * @param toPath - The absolute path of the outbound node that is referenced.
+     */
+    addedGCOutboundRoute(fromPath: string, toPath: string): void;
+    /**
+     * Updates the used routes of the channel and its child contexts. The channel must be loaded before calling this.
+     * It is called in these two scenarios:
+     * 1. When the used routes of the data store is updated and the data store is loaded.
+     * 2. When the data store is realized. This updates the channel's used routes as per last GC run.
+     */
+    private updateChannelUsedRoutes;
+    /**
+     * @deprecated 0.18.Should call request on the runtime directly
+     */
+    request(request: IRequest): Promise<IResponse>;
+    submitMessage(type: string, content: any, localOpMetadata: unknown): void;
+    /**
+     * This is called from a SharedSummaryBlock that does not generate ops but only wants to be part of the summary.
+     * It indicates that there is data in the object that needs to be summarized.
+     * We will update the latestSequenceNumber of the summary tracker of this
+     * store and of the object's channel.
+     *
+     * @param address - The address of the channel that is dirty.
+     *
+     */
+    setChannelDirty(address: string): void;
+    /**
+     * Submits the signal to be sent to other clients.
+     * @param type - Type of the signal.
+     * @param content - Content of the signal.
+     * @param targetClientId - When specified, the signal is only sent to the provided client id.
+     */
+    submitSignal(type: string, content: any, targetClientId?: string): void;
+    /**
+     * This is called by the data store channel when it becomes locally visible indicating that it is ready to become
+     * globally visible now.
+     */
+    makeLocallyVisible(): void;
+    protected processPendingOps(channel: IFluidDataStoreChannel): void;
+    protected completeBindingRuntime(channel: IFluidDataStoreChannel): void;
+    protected bindRuntime(channel: IFluidDataStoreChannel, existing: boolean): Promise<void>;
+    getAbsoluteUrl(relativeUrl: string): Promise<string | undefined>;
+    /**
+     * Get the data required when attaching this context's DataStore.
+     * Used for both Container Attach and DataStore Attach.
+     *
+     * @returns the summary, type, and GC Data for this context's DataStore.
+     */
+    abstract getAttachData(includeGCData: boolean, telemetryContext?: ITelemetryContext): {
+        attachSummary: ISummaryTreeWithStats;
+        type: string;
+    };
+    abstract getInitialSnapshotDetails(): Promise<ISnapshotDetails>;
+    /**
+     * @deprecated Sets the datastore as root, for aliasing purposes: #7948
+     * This method should not be used outside of the aliasing context.
+     * It will be removed, as the source of truth for this flag will be the aliasing blob.
+     */
+    setInMemoryRoot(): void;
+    /**
+     * @deprecated The functionality to get base GC details has been moved to summarizer node.
+     */
+    getBaseGCDetails(): Promise<IGarbageCollectionDetailsBase>;
+    reSubmit(type: string, contents: any, localOpMetadata: unknown): void;
+    rollback(type: string, contents: any, localOpMetadata: unknown): void;
+    applyStashedOp(contents: any): Promise<unknown>;
+    private verifyNotClosed;
+    /**
+     * Summarizer client should not have local changes. These changes can become part of the summary and can break
+     * eventual consistency. For example, the next summary (say at ref seq# 100) may contain these changes whereas
+     * other clients that are up-to-date till seq# 100 may not have them yet.
+     */
+    protected identifyLocalChangeInSummarizer(eventName: string, type?: string): void;
+    getCreateChildSummarizerNodeFn(id: string, createParam: CreateChildSummarizerNodeParam): (summarizeInternal: SummarizeInternalFn, getGCDataFn: (fullGC?: boolean) => Promise<IGarbageCollectionData>) => ISummarizerNodeWithGC;
+    deleteChildSummarizerNode(id: string): void;
+    uploadBlob(blob: ArrayBufferLike, signal?: AbortSignal): Promise<IFluidHandle<ArrayBufferLike>>;
+}
+
 /**
  * @internal
  */
@@ -695,8 +1219,6 @@ export declare type GCNodeType = (typeof GCNodeType)[keyof typeof GCNodeType];
  */
 export declare type GCVersion = number;
 
-export { generateStableId }
-
 /**
  * A single summary which has already been acked by the server.
  * @alpha
@@ -839,7 +1361,7 @@ export declare interface IContainerRuntimeMetadata extends ICreateContainerMetad
     /** GUID to identify a document in telemetry */
     readonly telemetryDocumentId?: string;
     /** True if the runtime IdCompressor is enabled */
-    readonly idCompressorEnabled?: boolean;
+    readonly idCompressorMode?: IdCompressorMode;
 }
 
 /**
@@ -898,7 +1420,7 @@ export declare interface IContainerRuntimeOptions {
      * Enable the IdCompressor in the runtime.
      * @experimental Not ready for use.
      */
-    readonly enableRuntimeIdCompressor?: boolean;
+    readonly enableRuntimeIdCompressor?: IdCompressorMode;
     /**
      * If enabled, the runtime will block all attempts to send an op inside the
      * {@link ContainerRuntime#ensureNoDataModelChanges} callback. The callback is used by
@@ -932,6 +1454,20 @@ export declare interface ICreateContainerMetadata {
     createContainerTimestamp?: number;
 }
 
+/**
+ * ID Compressor mode.
+ * "on" - compressor is On. It's loaded as part of container load. This mode is sticky - once on, compressor is On for all
+ * sessions for a given document. This results in IContainerRuntime.idCompressor to be always available.
+ * "delayed" - ID compressor bundle is loaded only on establishing of first delta connection, i.e. it does not impact boot of cotnainer.
+ * In such mode IContainerRuntime.idCompressor is not made available (unless previous sessions of same document had it "On").
+ * The only thing that is available is IContainerRuntime.generateDocumentUniqueId() that provides opportunistically short IDs.
+ * "off" - ID compressor is not laoded (unless it is "on" due to previous session for same document having it "on").
+ * While IContainerRuntime.generateDocumentUniqueId() is available, it will produce long IDs that are do not compress well.
+ *
+ * @alpha
+ */
+export declare type IdCompressorMode = "on" | "delayed" | "off";
+
 /**
  * Options to use when enqueueing a summarize attempt.
  * @alpha
@@ -948,6 +1484,41 @@ export declare interface IEnqueueSummarizeOptions extends IOnDemandSummarizeOpti
     readonly override?: boolean;
 }
 
+/** @internal */
+export declare interface IFluidDataStoreContextEvents extends IEvent_2 {
+    (event: "attaching" | "attached", listener: () => void): any;
+}
+
+/**
+ * This is interface that every context should implement.
+ * This interface is used for context's parent - ChannelCollection.
+ * It should not be exposed to any other users of context.
+ * @internal
+ */
+export declare interface IFluidDataStoreContextInternal extends IFluidDataStoreContext {
+    getAttachData(includeGCData: boolean, telemetryContext?: ITelemetryContext): {
+        attachSummary: ISummaryTreeWithStats;
+        type: string;
+    };
+    getInitialSnapshotDetails(): Promise<ISnapshotDetails>;
+    realize(): Promise<IFluidDataStoreChannel>;
+    isRoot(): Promise<boolean>;
+}
+
+/**
+ * Properties necessary for creating a FluidDataStoreContext
+ * @internal
+ */
+export declare interface IFluidDataStoreContextProps {
+    readonly id: string;
+    readonly parentContext: IFluidParentContext;
+    readonly storage: IDocumentStorageService;
+    readonly scope: FluidObject;
+    readonly createSummarizerNodeFn: CreateChildSummarizerNodeFn;
+    readonly pkg?: Readonly<string[]>;
+    readonly loadingGroupId?: string;
+}
+
 /**
  * GC-specific metadata to be written into the summary.
  *
@@ -1091,6 +1662,28 @@ export declare interface IGenerateSummaryTreeResult extends Omit<IBaseSummarizeR
     readonly forcedFullTree: boolean;
 }
 
+/**
+ * Properties necessary for creating a local FluidDataStoreContext
+ * @internal
+ */
+export declare interface ILocalDetachedFluidDataStoreContextProps extends ILocalFluidDataStoreContextProps {
+    readonly channelToDataStoreFn: (channel: IFluidDataStoreChannel) => IDataStore;
+}
+
+/**
+ * Properties necessary for creating a local FluidDataStoreContext
+ * @internal
+ */
+export declare interface ILocalFluidDataStoreContextProps extends IFluidDataStoreContextProps {
+    readonly pkg: Readonly<string[]> | undefined;
+    readonly snapshotTree: ISnapshotTree | undefined;
+    readonly makeLocallyVisibleFn: () => void;
+    /**
+     * @deprecated 0.16 Issue #1635, #3631
+     */
+    readonly createProps?: any;
+}
+
 /**
  * The statistics of the system state after a garbage collection mark phase run.
  * @alpha
@@ -1183,14 +1776,20 @@ export declare interface ISerializedElection {
     readonly electedParentId: string | undefined;
 }
 
+/** @internal */
+export declare interface ISnapshotDetails {
+    pkg: readonly string[];
+    isRootDataStore: boolean;
+    snapshot?: ISnapshotTree;
+    sequenceNumber?: number;
+}
+
 /**
  * @deprecated please use version in driver-utils
  * @internal
  */
 export declare function isRuntimeMessage(message: ISequencedDocumentMessage): boolean;
 
-export { isStableId }
-
 /**
  * Results of submitSummary after submitting the summarize op.
  * @alpha
@@ -1213,6 +1812,8 @@ export declare interface ISubmitSummaryOptions extends ISummarizeOptions {
     readonly cancellationToken: ISummaryCancellationToken;
     /** Summarization may be attempted multiple times. This tells whether this is the final summarization attempt. */
     readonly finalAttempt?: boolean;
+    /** The sequence number of the latest summary used to validate if summary state is correct before summarizing */
+    readonly latestSummaryRefSeqNum: number;
 }
 
 /**
@@ -1251,7 +1852,7 @@ export declare interface ISummarizer extends IEventProvider<ISummarizerEvents> {
     readonly ISummarizer?: ISummarizer;
     stop(reason: SummarizerStopReason): void;
     close(): void;
-    run(onBehalfOf: string, disableHeuristics?: boolean): Promise<SummarizerStopReason>;
+    run(onBehalfOf: string): Promise<SummarizerStopReason>;
     /**
      * Attempts to generate a summary on demand. If already running, takes no action.
      * @param options - options controlling the summarize attempt
@@ -1534,6 +2135,48 @@ export declare interface IUploadSummaryResult extends Omit<IGenerateSummaryTreeR
     readonly uploadDuration: number;
 }
 
+/**
+ * context implementation for "attached" data store runtime.
+ * Various workflows (snapshot creation, requests) result in .realize() being called
+ * on context, resulting in instantiation and attachment of runtime.
+ * Runtime is created using data store factory that is associated with this context.
+ * @internal
+ */
+export declare class LocalFluidDataStoreContext extends LocalFluidDataStoreContextBase {
+    constructor(props: ILocalFluidDataStoreContextProps);
+}
+
+/**
+ * Base class for detached & attached context classes
+ * @internal
+ */
+export declare class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
+    private readonly snapshotTree;
+    /**
+     * @deprecated 0.16 Issue #1635, #3631
+     */
+    readonly createProps?: any;
+    constructor(props: ILocalFluidDataStoreContextProps);
+    setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
+    /**
+     * @see FluidDataStoreContext.getAttachData
+     */
+    getAttachData(includeGCData: boolean, telemetryContext?: ITelemetryContext): {
+        attachSummary: ISummaryTreeWithStats;
+        type: string;
+    };
+    private readonly initialSnapshotDetailsP;
+    getInitialSnapshotDetails(): Promise<ISnapshotDetails>;
+    /**
+     * A context should only be marked as deleted when its a remote context.
+     * Session Expiry at the runtime level should have closed the container creating the local data store context
+     * before delete is even possible. Session Expiry is at 30 days, and sweep is done 36+ days later from the time
+     * it was unreferenced. Thus the sweeping container should have loaded from a snapshot and thus creating a remote
+     * context.
+     */
+    delete(): void;
+}
+
 /**
  * Can be useful in testing as well as in places where caller does not use cancellation.
  * This object implements ISummaryCancellationToken interface but cancellation is never leveraged.
@@ -1560,6 +2203,17 @@ export declare interface RecentlyAddedContainerRuntimeMessageDetails {
     compatDetails: IContainerRuntimeMessageCompatDetails;
 }
 
+/**
+ * The full set of parsed header data that may be found on Runtime requests
+ * @internal
+ */
+export declare interface RuntimeHeaderData {
+    wait?: boolean;
+    viaHandle?: boolean;
+    allowTombstone?: boolean;
+    allowInactive?: boolean;
+}
+
 /**
  * Accepted header keys for requests coming to the runtime.
  * @internal
@@ -1702,7 +2356,7 @@ export declare type SummarizeResultPart<TSuccess, TFailure = undefined> = {
  * @alpha
  */
 export declare type SummarizerStopReason = 
-/** Summarizer client failed to summarize in all 3 consecutive attempts. */
+/** Summarizer client failed to summarize in all attempts. */
 "failToSummarize"
 /** Parent client reported that it is no longer connected. */
 | "parentNotConnected"
@@ -1793,6 +2447,20 @@ export declare type SummaryStage = SubmitSummaryResult["stage"] | "unknown";
  */
 export declare const TombstoneResponseHeaderKey = "isTombstoned";
 
+/**
+ * Represents an unrecognized TypedContainerRuntimeMessage, e.g. a message from a future version of the container runtime.
+ * @internal
+ */
+export declare interface UnknownContainerRuntimeMessage extends Partial<RecentlyAddedContainerRuntimeMessageDetails> {
+    /** Invalid type of the op, within the ContainerRuntime's domain. This value should never exist at runtime.
+     * This is useful for type narrowing but should never be used as an actual message type at runtime.
+     * Actual value will not be "__unknown...", but the type `Exclude<string, ContainerMessageType>` is not supported.
+     */
+    type: "__unknown_container_message_type__never_use_as_value__";
+    /** Domain-specific contents, but not decipherable by an unknown op. */
+    contents: unknown;
+}
+
 /**
  * Unpacks runtime messages.
  *