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

package/api-report/container-runtime.api.md

@@ -4,17 +4,19 @@
 
 ```ts
 
-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';
@@ -24,16 +26,22 @@ 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';
@@ -41,17 +49,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';
 
 // @internal
@@ -63,7 +76,103 @@ export const AllowInactiveRequestHeaderKey = "allowInactive";
 // @alpha
 export const AllowTombstoneRequestHeaderKey = "allowTombstone";
 
-export { assertIsStableId }
+// @internal
+export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
+    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>);
+    // (undocumented)
+    get aliases(): ReadonlyMap<string, string>;
+    // (undocumented)
+    protected applyStashedChannelChannelOp(envelope: IEnvelope): Promise<unknown>;
+    // (undocumented)
+    applyStashedOp(content: unknown): Promise<unknown>;
+    // (undocumented)
+    readonly attachOpFiredForDataStore: Set<string>;
+    // (undocumented)
+    protected readonly baseSnapshot: ISnapshotTree | undefined;
+    // (undocumented)
+    readonly containerLoadStats: {
+        readonly containerLoadDataStoreCount: number;
+        readonly referencedDataStoreCount: number;
+    };
+    // (undocumented)
+    protected readonly contexts: DataStoreContexts;
+    // (undocumented)
+    protected createContext<T extends LocalFluidDataStoreContext>(id: string, pkg: Readonly<string[]>, contextCtor: new (props: ILocalDetachedFluidDataStoreContextProps) => T, createProps?: any, loadingGroupId?: string): T;
+    // (undocumented)
+    createDataStoreContext(pkg: Readonly<string[]>, props?: any, loadingGroupId?: string): IFluidDataStoreContextInternal;
+    protected createDataStoreId(): string;
+    // (undocumented)
+    createDetachedDataStore(pkg: Readonly<string[]>, loadingGroupId?: string): IFluidDataStoreContextDetached;
+    deleteSweepReadyNodes(sweepReadyDataStoreRoutes: readonly string[]): readonly string[];
+    // (undocumented)
+    readonly dispose: () => void;
+    // (undocumented)
+    get disposed(): boolean;
+    // (undocumented)
+    readonly entryPoint: IFluidHandle<FluidObject>;
+    getAttachSummary(telemetryContext?: ITelemetryContext): ISummaryTreeWithStats;
+    // (undocumented)
+    getDataStore(id: string, requestHeaderData: RuntimeHeaderData): Promise<IFluidDataStoreContextInternal>;
+    getDataStoreIfAvailable(id: string, requestHeaderData: RuntimeHeaderData): Promise<IFluidDataStoreContextInternal | undefined>;
+    getDataStorePackagePath(nodePath: string): Promise<readonly string[] | undefined>;
+    getGCData(fullGC?: boolean): Promise<IGarbageCollectionData>;
+    getGCNodeType(nodePath: string): GCNodeType | undefined;
+    // (undocumented)
+    internalId(maybeAlias: string): string;
+    makeVisibleAndAttachGraph(): void;
+    // (undocumented)
+    protected readonly mc: MonitoringContext;
+    // (undocumented)
+    readonly parentContext: IFluidParentContext;
+    // (undocumented)
+    get pendingAliases(): Map<string, Promise<AliasResult>>;
+    // (undocumented)
+    process(message: ISequencedDocumentMessage, local: boolean, localMessageMetadata: unknown, addedOutboundReference?: (fromNodePath: string, toNodePath: string) => void): void;
+    // (undocumented)
+    processAliasMessageCore(internalId: string, alias: string): boolean;
+    // (undocumented)
+    protected processChannelOp(address: string, message: ISequencedDocumentMessage, local: boolean, localMessageMetadata: unknown): void;
+    // (undocumented)
+    processSignal(messageArg: IInboundSignalMessage, local: boolean): void;
+    // (undocumented)
+    request(request: IRequest): Promise<IResponse>;
+    // (undocumented)
+    reSubmit(type: string, content: any, localOpMetadata: unknown): void;
+    // (undocumented)
+    protected reSubmitChannelOp(type: string, content: any, localOpMetadata: unknown): void;
+    // (undocumented)
+    rollback(type: string, content: any, localOpMetadata: unknown): void;
+    // (undocumented)
+    setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
+    // (undocumented)
+    setConnectionState(connected: boolean, clientId?: string): void;
+    // (undocumented)
+    get size(): number;
+    // (undocumented)
+    protected submitAttachChannelOp(localContext: LocalFluidDataStoreContext): void;
+    // (undocumented)
+    summarize(fullTree: boolean, trackState: boolean, telemetryContext?: ITelemetryContext): Promise<ISummaryTreeWithStats>;
+    updateStateBeforeGC(): Promise<void>;
+    updateTombstonedRoutes(tombstonedRoutes: readonly string[]): void;
+    updateUsedRoutes(usedRoutes: readonly string[]): void;
+    // (undocumented)
+    waitIfPendingAlias(maybeAlias: string): Promise<AliasResult>;
+    // (undocumented)
+    protected wrapContextForInnerChannel(id: string): IFluidParentContext;
+}
+
+// @internal (undocumented)
+export class ChannelCollectionFactory<T extends ChannelCollection = ChannelCollection> implements IFluidDataStoreFactory {
+    constructor(registryEntries: NamedFluidDataStoreRegistryEntries, provideEntryPoint: (runtime: IFluidDataStoreChannel) => Promise<FluidObject>, ctor: (...args: ConstructorParameters<typeof ChannelCollection>) => T);
+    // (undocumented)
+    get IFluidDataStoreFactory(): this;
+    // (undocumented)
+    IFluidDataStoreRegistry: IFluidDataStoreRegistry;
+    // (undocumented)
+    instantiateDataStore(context: IFluidDataStoreContext, _existing: boolean): Promise<IFluidDataStoreChannel>;
+    // (undocumented)
+    readonly type = "ChannelCollectionChannel";
+}
 
 // @internal
 export type CompatModeBehavior =
@@ -98,10 +207,14 @@ export enum ContainerMessageType {
 
 // @alpha
 export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents & ISummarizerEvents> implements IContainerRuntime, IRuntime, ISummarizerRuntime, ISummarizerInternalsProvider, IProvideFluidHandleContext {
-    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);
     // (undocumented)
     protected addContainerStateToSummary(summaryTree: ISummaryTreeWithStats, fullTree: boolean, trackState: boolean, telemetryContext?: ITelemetryContext): void;
-    addedGCOutboundReference(srcHandle: IFluidHandle, outboundHandle: IFluidHandle): void;
+    addedGCOutboundReference(srcHandle: {
+        absolutePath: string;
+    }, outboundHandle: {
+        absolutePath: string;
+    }): void;
     // (undocumented)
     get attachState(): AttachState;
     // (undocumented)
@@ -115,20 +228,21 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents
         runSweep?: boolean;
         fullGC?: boolean;
     }, telemetryContext?: ITelemetryContext): Promise<IGCStats | undefined>;
+    protected compressorLoadInitiated: boolean;
     // (undocumented)
     get connected(): boolean;
     // (undocumented)
-    createDataStore(pkg: string | string[], groupId?: string): Promise<IDataStore>;
-    // @deprecated (undocumented)
-    _createDataStoreWithProps(pkg: string | string[], props?: any, id?: string): Promise<IDataStore>;
+    get containerRuntime(): this;
     // (undocumented)
-    createDetachedDataStore(pkg: Readonly<string[]>, groupId?: string): IFluidDataStoreContextDetached;
+    createDataStore(pkg: Readonly<string | string[]>, loadingGroupId?: string): Promise<IDataStore>;
+    // @deprecated (undocumented)
+    _createDataStoreWithProps(pkg: Readonly<string | string[]>, props?: any): Promise<IDataStore>;
     // (undocumented)
-    createDetachedRootDataStore(pkg: Readonly<string[]>, rootDataStoreId: string): IFluidDataStoreContextDetached;
+    createDetachedDataStore(pkg: Readonly<string[]>, loadingGroupId?: string): IFluidDataStoreContextDetached;
     createSummary(blobRedirectTable?: Map<string, string>, telemetryContext?: ITelemetryContext): ISummaryTree;
+    // (undocumented)
+    deleteChildSummarizerNode(id: string): void;
     deleteSweepReadyNodes(sweepReadyRoutes: readonly string[]): readonly string[];
-    // @deprecated (undocumented)
-    deleteUnusedNodes(unusedRoutes: readonly string[]): string[];
     readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
     // (undocumented)
     dispose(error?: Error): void;
@@ -143,23 +257,32 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents
     get flushMode(): FlushMode;
     get gcThrowOnTombstoneUsage(): boolean;
     get gcTombstoneEnforcementAllowed(): boolean;
+    generateDocumentUniqueId(): string | (number & {
+        readonly SessionUnique: "cea55054-6b82-4cbf-ad19-1fa645ea3b3e";
+    } & {
+        readonly OpNormalized: "9209432d-a959-4df7-b2ad-767ead4dbcae";
+    });
     // (undocumented)
     readonly getAbsoluteUrl: (relativeUrl: string) => Promise<string | undefined>;
     getAliasedDataStoreEntryPoint(alias: string): Promise<IFluidHandle<FluidObject> | undefined>;
     // (undocumented)
     getAudience(): IAudience;
-    getCurrentReferenceTimestampMs(): number | undefined;
     // (undocumented)
+    getCreateChildSummarizerNodeFn(id: string, createParam: CreateChildSummarizerNodeParam): (summarizeInternal: SummarizeInternalFn, getGCDataFn: (fullGC?: boolean) => Promise<IGarbageCollectionData>) => ISummarizerNodeWithGC;
+    getCurrentReferenceTimestampMs(): number | undefined;
     getEntryPoint(): Promise<FluidObject>;
     getGCData(fullGC?: boolean): Promise<IGarbageCollectionData>;
     getGCNodePackagePath(nodePath: string): Promise<readonly string[] | undefined>;
     getNodeType(nodePath: string): GCNodeType;
     // (undocumented)
-    getPendingLocalState(props?: IGetPendingLocalStateProps): Promise<unknown>;
+    getPendingLocalState(props?: IGetPendingLocalStateProps): unknown;
     // (undocumented)
     getQuorum(): IQuorumClients;
-    // (undocumented)
-    idCompressor: (IIdCompressor & IIdCompressorCore) | undefined;
+    getSnapshotForLoadingGroupId(loadingGroupIds: string[], pathParts: string[]): Promise<{
+        snapshotTree: ISnapshotTree;
+        sequenceNumber: number;
+    }>;
+    get idCompressor(): (IIdCompressor & IIdCompressorCore) | undefined;
     // (undocumented)
     get IFluidDataStoreRegistry(): IFluidDataStoreRegistry;
     // (undocumented)
@@ -178,10 +301,11 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents
     // (undocumented)
     readonly logger: ITelemetryLoggerExt;
     // (undocumented)
-    notifyOpReplay(message: ISequencedDocumentMessage): Promise<void>;
+    makeLocallyVisible(): void;
     // (undocumented)
-    readonly options: ILoaderOptions;
+    notifyOpReplay(message: ISequencedDocumentMessage): Promise<void>;
     // (undocumented)
+    readonly options: Record<string | number, any>;
     orderSequentially<T>(callback: () => T): T;
     // (undocumented)
     process(messageArg: ISequencedDocumentMessage, local: boolean): void;
@@ -194,14 +318,13 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents
     // (undocumented)
     setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
     // (undocumented)
+    setChannelDirty(address: string): void;
+    // (undocumented)
     setConnectionState(connected: boolean, clientId?: string): void;
     // (undocumented)
     get storage(): IDocumentStorageService;
     // (undocumented)
-    submitDataStoreAliasOp(contents: any, localOpMetadata: unknown): void;
-    // (undocumented)
-    submitDataStoreOp(id: string, contents: any, localOpMetadata?: unknown): void;
-    submitDataStoreSignal(address: string, type: string, content: any, targetClientId?: string): void;
+    submitMessage(type: ContainerMessageType.FluidDataStoreOp | ContainerMessageType.Alias | ContainerMessageType.Attach, contents: any, localOpMetadata?: unknown): void;
     submitSignal(type: string, content: any, targetClientId?: string): void;
     submitSummary(options: ISubmitSummaryOptions): Promise<SubmitSummaryResult>;
     summarize(options: {
@@ -217,7 +340,6 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents
     get summarizerClientId(): string | undefined;
     updateStateBeforeGC(): Promise<void>;
     updateTombstonedRoutes(tombstonedRoutes: readonly string[]): void;
-    updateUnusedRoutes(unusedRoutes: readonly string[]): void;
     updateUsedRoutes(usedRoutes: readonly string[]): void;
     // (undocumented)
     uploadBlob(blob: ArrayBufferLike, signal?: AbortSignal): Promise<IFluidHandle<ArrayBufferLike>>;
@@ -230,11 +352,39 @@ export interface ContainerRuntimeMessage {
     type: ContainerMessageType;
 }
 
+// @internal (undocumented)
+export class DataStoreContexts implements Iterable<[string, FluidDataStoreContext]>, IDisposable {
+    // (undocumented)
+    [Symbol.iterator](): Iterator<[string, FluidDataStoreContext]>;
+    constructor(baseLogger: ITelemetryBaseLogger);
+    addBoundOrRemoted(context: FluidDataStoreContext): void;
+    addUnbound(context: LocalFluidDataStoreContext): void;
+    bind(id: string): void;
+    // (undocumented)
+    delete(id: string): boolean;
+    // (undocumented)
+    readonly dispose: () => void;
+    // (undocumented)
+    get disposed(): boolean;
+    // (undocumented)
+    get(id: string): FluidDataStoreContext | undefined;
+    getBoundOrRemoted(id: string, wait: boolean): Promise<FluidDataStoreContext | undefined>;
+    getUnbound(id: string): LocalFluidDataStoreContext | undefined;
+    // (undocumented)
+    has(id: string): boolean;
+    // (undocumented)
+    isNotBound(id: string): boolean;
+    // (undocumented)
+    notBoundLength(): number;
+    // (undocumented)
+    get size(): number;
+}
+
 // @alpha (undocumented)
 export const DefaultSummaryConfiguration: ISummaryConfiguration;
 
 // @internal
-export function detectOutboundReferences(envelope: IEnvelope, addedOutboundReference: (fromNodePath: string, toNodePath: string) => void): void;
+export function detectOutboundReferences(address: string, contents: unknown, addedOutboundReference: (fromNodePath: string, toNodePath: string) => void): void;
 
 // @alpha (undocumented)
 export type EnqueueSummarizeResult = (ISummarizeResults & {
@@ -247,6 +397,145 @@ export type EnqueueSummarizeResult = (ISummarizeResults & {
     readonly overridden?: undefined;
 };
 
+// @internal
+export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidDataStoreContextEvents> implements IFluidDataStoreContextInternal, IFluidParentContext, IDisposable {
+    constructor(props: IFluidDataStoreContextProps, existing: boolean, isLocalDataStore: boolean, makeLocallyVisibleFn: () => void);
+    // @deprecated (undocumented)
+    addedGCOutboundReference(srcHandle: IFluidHandle, outboundHandle: IFluidHandle): void;
+    addedGCOutboundRoute(fromPath: string, toPath: string): void;
+    // (undocumented)
+    applyStashedOp(contents: any): Promise<unknown>;
+    // (undocumented)
+    get attachState(): AttachState;
+    // (undocumented)
+    protected _attachState: AttachState;
+    // (undocumented)
+    get baseSnapshot(): ISnapshotTree | undefined;
+    // (undocumented)
+    protected _baseSnapshot: ISnapshotTree | undefined;
+    // (undocumented)
+    protected bindRuntime(channel: IFluidDataStoreChannel, existing: boolean): Promise<void>;
+    // (undocumented)
+    protected channel: IFluidDataStoreChannel | undefined;
+    // (undocumented)
+    protected channelP: Promise<IFluidDataStoreChannel> | undefined;
+    // (undocumented)
+    get clientDetails(): IClientDetails;
+    // (undocumented)
+    get clientId(): string | undefined;
+    // (undocumented)
+    protected completeBindingRuntime(channel: IFluidDataStoreChannel): void;
+    // (undocumented)
+    get connected(): boolean;
+    // (undocumented)
+    get containerRuntime(): IContainerRuntimeBase;
+    delete(): void;
+    // (undocumented)
+    deleteChildSummarizerNode(id: string): void;
+    protected deleted: boolean;
+    // (undocumented)
+    get deltaManager(): IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    // (undocumented)
+    protected detachedRuntimeCreation: boolean;
+    // (undocumented)
+    dispose(): void;
+    // (undocumented)
+    get disposed(): boolean;
+    // (undocumented)
+    ensureNoDataModelChanges<T>(callback: () => T): T;
+    // (undocumented)
+    protected factoryFromPackagePath(): Promise<IFluidDataStoreFactory>;
+    readonly gcThrowOnTombstoneUsage: boolean;
+    // (undocumented)
+    readonly gcTombstoneEnforcementAllowed: boolean;
+    // (undocumented)
+    getAbsoluteUrl(relativeUrl: string): Promise<string | undefined>;
+    abstract getAttachData(includeGCData: boolean, telemetryContext?: ITelemetryContext): {
+        attachSummary: ISummaryTreeWithStats;
+        type: string;
+    };
+    // (undocumented)
+    getAudience(): IAudience;
+    // @deprecated (undocumented)
+    getBaseGCDetails(): Promise<IGarbageCollectionDetailsBase>;
+    // (undocumented)
+    getCreateChildSummarizerNodeFn(id: string, createParam: CreateChildSummarizerNodeParam): (summarizeInternal: SummarizeInternalFn, getGCDataFn: (fullGC?: boolean) => Promise<IGarbageCollectionData>) => ISummarizerNodeWithGC;
+    getGCData(fullGC?: boolean): Promise<IGarbageCollectionData>;
+    // (undocumented)
+    abstract getInitialSnapshotDetails(): Promise<ISnapshotDetails>;
+    // (undocumented)
+    getQuorum(): IQuorumClients;
+    // (undocumented)
+    readonly id: string;
+    // (undocumented)
+    get idCompressor(): IIdCompressor | undefined;
+    protected identifyLocalChangeInSummarizer(eventName: string, type?: string): void;
+    // (undocumented)
+    get IFluidDataStoreRegistry(): IFluidDataStoreRegistry | undefined;
+    // (undocumented)
+    get IFluidHandleContext(): IFluidHandleContext;
+    protected isInMemoryRoot(): boolean;
+    // (undocumented)
+    get isLoaded(): boolean;
+    // (undocumented)
+    readonly isLocalDataStore: boolean;
+    isRoot(): Promise<boolean>;
+    // (undocumented)
+    readonly loadingGroupId: string | undefined;
+    // (undocumented)
+    get logger(): ITelemetryBaseLogger;
+    makeLocallyVisible(): void;
+    // (undocumented)
+    protected readonly mc: MonitoringContext;
+    // (undocumented)
+    get options(): Record<string | number, any>;
+    // (undocumented)
+    get packagePath(): readonly string[];
+    // (undocumented)
+    protected pending: ISequencedDocumentMessage[] | undefined;
+    // (undocumented)
+    protected pkg?: readonly string[];
+    // (undocumented)
+    process(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    // (undocumented)
+    protected processPendingOps(channel: IFluidDataStoreChannel): void;
+    // (undocumented)
+    processSignal(message: IInboundSignalMessage, local: boolean): void;
+    // (undocumented)
+    realize(): Promise<IFluidDataStoreChannel>;
+    // (undocumented)
+    protected registry: IFluidDataStoreRegistry | undefined;
+    // @deprecated (undocumented)
+    request(request: IRequest): Promise<IResponse>;
+    // (undocumented)
+    reSubmit(type: string, contents: any, localOpMetadata: unknown): void;
+    // (undocumented)
+    rollback(type: string, contents: any, localOpMetadata: unknown): void;
+    // (undocumented)
+    readonly scope: FluidObject;
+    // (undocumented)
+    abstract setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
+    setChannelDirty(address: string): void;
+    setConnectionState(connected: boolean, clientId?: string): void;
+    // @deprecated (undocumented)
+    setInMemoryRoot(): void;
+    // (undocumented)
+    setTombstone(tombstone: boolean): void;
+    // (undocumented)
+    readonly storage: IDocumentStorageService;
+    // (undocumented)
+    submitMessage(type: string, content: any, localOpMetadata: unknown): void;
+    submitSignal(type: string, content: any, targetClientId?: string): void;
+    summarize(fullTree?: boolean, trackState?: boolean, telemetryContext?: ITelemetryContext): Promise<ISummarizeResult>;
+    // (undocumented)
+    protected readonly summarizerNode: ISummarizerNodeWithGC;
+    // (undocumented)
+    get tombstoned(): boolean;
+    updateUsedRoutes(usedRoutes: string[]): void;
+    // (undocumented)
+    uploadBlob(blob: ArrayBufferLike, signal?: AbortSignal): Promise<IFluidHandle<ArrayBufferLike>>;
+}
+
 // @internal (undocumented)
 export class FluidDataStoreRegistry implements IFluidDataStoreRegistry {
     constructor(namedEntries: NamedFluidDataStoreRegistryEntries);
@@ -278,8 +567,6 @@ export type GCNodeType = (typeof GCNodeType)[keyof typeof GCNodeType];
 // @alpha (undocumented)
 export type GCVersion = number;
 
-export { generateStableId }
-
 // @alpha
 export interface IAckedSummary {
     // (undocumented)
@@ -384,7 +671,7 @@ export interface IContainerRuntimeMessageCompatDetails {
 // @alpha (undocumented)
 export interface IContainerRuntimeMetadata extends ICreateContainerMetadata, IGCMetadata {
     readonly disableIsolatedChannels?: true;
-    readonly idCompressorEnabled?: boolean;
+    readonly idCompressorMode?: IdCompressorMode;
     readonly message: ISummaryMetadataMessage | undefined;
     // (undocumented)
     readonly summaryFormatVersion: 1;
@@ -398,7 +685,7 @@ export interface IContainerRuntimeOptions {
     readonly compressionOptions?: ICompressionRuntimeOptions;
     readonly enableGroupedBatching?: boolean;
     readonly enableOpReentryCheck?: boolean;
-    readonly enableRuntimeIdCompressor?: boolean;
+    readonly enableRuntimeIdCompressor?: IdCompressorMode;
     readonly flushMode?: FlushMode;
     // (undocumented)
     readonly gcOptions?: IGCRuntimeOptions;
@@ -414,12 +701,54 @@ export interface ICreateContainerMetadata {
     createContainerTimestamp?: number;
 }
 
+// @alpha
+export type IdCompressorMode = "on" | "delayed" | "off";
+
 // @alpha
 export interface IEnqueueSummarizeOptions extends IOnDemandSummarizeOptions {
     readonly afterSequenceNumber?: number;
     readonly override?: boolean;
 }
 
+// @internal (undocumented)
+export interface IFluidDataStoreContextEvents extends IEvent_2 {
+    // (undocumented)
+    (event: "attaching" | "attached", listener: () => void): any;
+}
+
+// @internal
+export interface IFluidDataStoreContextInternal extends IFluidDataStoreContext {
+    // (undocumented)
+    getAttachData(includeGCData: boolean, telemetryContext?: ITelemetryContext): {
+        attachSummary: ISummaryTreeWithStats;
+        type: string;
+    };
+    // (undocumented)
+    getInitialSnapshotDetails(): Promise<ISnapshotDetails>;
+    // (undocumented)
+    isRoot(): Promise<boolean>;
+    // (undocumented)
+    realize(): Promise<IFluidDataStoreChannel>;
+}
+
+// @internal
+export interface IFluidDataStoreContextProps {
+    // (undocumented)
+    readonly createSummarizerNodeFn: CreateChildSummarizerNodeFn;
+    // (undocumented)
+    readonly id: string;
+    // (undocumented)
+    readonly loadingGroupId?: string;
+    // (undocumented)
+    readonly parentContext: IFluidParentContext;
+    // (undocumented)
+    readonly pkg?: Readonly<string[]>;
+    // (undocumented)
+    readonly scope: FluidObject;
+    // (undocumented)
+    readonly storage: IDocumentStorageService;
+}
+
 // @alpha
 export interface IGCMetadata {
     readonly gcFeature?: GCVersion;
@@ -465,6 +794,24 @@ export interface IGenerateSummaryTreeResult extends Omit<IBaseSummarizeResult, "
     readonly summaryTree: ISummaryTree;
 }
 
+// @internal
+export interface ILocalDetachedFluidDataStoreContextProps extends ILocalFluidDataStoreContextProps {
+    // (undocumented)
+    readonly channelToDataStoreFn: (channel: IFluidDataStoreChannel) => IDataStore;
+}
+
+// @internal
+export interface ILocalFluidDataStoreContextProps extends IFluidDataStoreContextProps {
+    // @deprecated (undocumented)
+    readonly createProps?: any;
+    // (undocumented)
+    readonly makeLocallyVisibleFn: () => void;
+    // (undocumented)
+    readonly pkg: Readonly<string[]> | undefined;
+    // (undocumented)
+    readonly snapshotTree: ISnapshotTree | undefined;
+}
+
 // @alpha
 export interface IMarkPhaseStats {
     attachmentBlobCount: number;
@@ -516,11 +863,21 @@ export interface ISerializedElection {
     readonly electionSequenceNumber: number;
 }
 
+// @internal (undocumented)
+export interface ISnapshotDetails {
+    // (undocumented)
+    isRootDataStore: boolean;
+    // (undocumented)
+    pkg: readonly string[];
+    // (undocumented)
+    sequenceNumber?: number;
+    // (undocumented)
+    snapshot?: ISnapshotTree;
+}
+
 // @internal @deprecated (undocumented)
 export function isRuntimeMessage(message: ISequencedDocumentMessage): boolean;
 
-export { isStableId }
-
 // @alpha
 export interface ISubmitSummaryOpResult extends Omit<IUploadSummaryResult, "stage" | "error"> {
     readonly clientSequenceNumber: number;
@@ -533,6 +890,7 @@ export interface ISubmitSummaryOpResult extends Omit<IUploadSummaryResult, "stag
 export interface ISubmitSummaryOptions extends ISummarizeOptions {
     readonly cancellationToken: ISummaryCancellationToken;
     readonly finalAttempt?: boolean;
+    readonly latestSummaryRefSeqNum: number;
     readonly summaryLogger: ITelemetryLoggerExt;
 }
 
@@ -562,7 +920,7 @@ export interface ISummarizer extends IEventProvider<ISummarizerEvents> {
     enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult;
     readonly ISummarizer?: ISummarizer;
     // (undocumented)
-    run(onBehalfOf: string, disableHeuristics?: boolean): Promise<SummarizerStopReason>;
+    run(onBehalfOf: string): Promise<SummarizerStopReason>;
     // (undocumented)
     stop(reason: SummarizerStopReason): void;
     summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults;
@@ -721,6 +1079,28 @@ export interface IUploadSummaryResult extends Omit<IGenerateSummaryTreeResult, "
     readonly uploadDuration: number;
 }
 
+// @internal
+export class LocalFluidDataStoreContext extends LocalFluidDataStoreContextBase {
+    constructor(props: ILocalFluidDataStoreContextProps);
+}
+
+// @internal
+export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
+    constructor(props: ILocalFluidDataStoreContextProps);
+    // @deprecated (undocumented)
+    readonly createProps?: any;
+    delete(): void;
+    // (undocumented)
+    getAttachData(includeGCData: boolean, telemetryContext?: ITelemetryContext): {
+        attachSummary: ISummaryTreeWithStats;
+        type: string;
+    };
+    // (undocumented)
+    getInitialSnapshotDetails(): Promise<ISnapshotDetails>;
+    // (undocumented)
+    setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
+}
+
 // @internal
 export const neverCancelledSummaryToken: ISummaryCancellationToken;
 
@@ -735,6 +1115,18 @@ export interface RecentlyAddedContainerRuntimeMessageDetails {
     compatDetails: IContainerRuntimeMessageCompatDetails;
 }
 
+// @internal
+export interface RuntimeHeaderData {
+    // (undocumented)
+    allowInactive?: boolean;
+    // (undocumented)
+    allowTombstone?: boolean;
+    // (undocumented)
+    viaHandle?: boolean;
+    // (undocumented)
+    wait?: boolean;
+}
+
 // @internal
 export enum RuntimeHeaders {
     viaHandle = "viaHandle",