@fluidframework/container-runtime 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.1

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

@@ -4,57 +4,66 @@
 
 ```ts
 
+import { AliasResult } from '@fluidframework/runtime-definitions/internal';
 import { AttachState } from '@fluidframework/container-definitions';
-import { ContainerWarning } from '@fluidframework/container-definitions';
-import { CreateChildSummarizerNodeParam } from '@fluidframework/runtime-definitions';
-import { FluidDataStoreRegistryEntry } from '@fluidframework/runtime-definitions';
+import { ContainerWarning } from '@fluidframework/container-definitions/internal';
+import { CreateChildSummarizerNodeFn } from '@fluidframework/runtime-definitions/internal';
+import { CreateChildSummarizerNodeParam } from '@fluidframework/runtime-definitions/internal';
+import { FluidDataStoreRegistryEntry } from '@fluidframework/runtime-definitions/internal';
 import { FluidObject } from '@fluidframework/core-interfaces';
-import { FlushMode } from '@fluidframework/runtime-definitions';
+import { FlushMode } from '@fluidframework/runtime-definitions/internal';
 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 { IContainerRuntimeEvents } from '@fluidframework/container-runtime-definitions';
+import { IContainerContext } from '@fluidframework/container-definitions/internal';
+import { IContainerRuntime } from '@fluidframework/container-runtime-definitions/internal';
+import { IContainerRuntimeBase } from '@fluidframework/runtime-definitions/internal';
+import { IContainerRuntimeEvents } from '@fluidframework/container-runtime-definitions/internal';
 import { ICriticalContainerError } from '@fluidframework/container-definitions';
-import { IDataStore } from '@fluidframework/runtime-definitions';
+import { IDataStore } from '@fluidframework/runtime-definitions/internal';
 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 { IDocumentStorageService } from '@fluidframework/driver-definitions/internal';
+import { IEnvelope } from '@fluidframework/runtime-definitions/internal';
 import { IEvent } from '@fluidframework/core-interfaces';
 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 { IFluidDataStoreChannel } from '@fluidframework/runtime-definitions/internal';
+import { IFluidDataStoreContext } from '@fluidframework/runtime-definitions/internal';
+import { IFluidDataStoreContextDetached } from '@fluidframework/runtime-definitions/internal';
+import { IFluidDataStoreFactory } from '@fluidframework/runtime-definitions/internal';
+import { IFluidDataStoreRegistry } from '@fluidframework/runtime-definitions/internal';
 import { IFluidHandle } from '@fluidframework/core-interfaces';
 import { IFluidHandleContext } from '@fluidframework/core-interfaces';
+import { IFluidParentContext } from '@fluidframework/runtime-definitions/internal';
 import { IGarbageCollectionData } from '@fluidframework/runtime-definitions';
-import { IGetPendingLocalStateProps } from '@fluidframework/container-definitions';
+import { IGarbageCollectionDetailsBase } from '@fluidframework/runtime-definitions/internal';
+import { IGetPendingLocalStateProps } from '@fluidframework/container-definitions/internal';
 import type { IIdCompressor } from '@fluidframework/id-compressor';
-import type { IIdCompressorCore } from '@fluidframework/id-compressor';
+import type { IIdCompressorCore } from '@fluidframework/id-compressor/internal';
+import { IInboundSignalMessage } from '@fluidframework/runtime-definitions';
 import { IProvideFluidHandleContext } from '@fluidframework/core-interfaces';
 import { IQuorumClients } from '@fluidframework/protocol-definitions';
 import { IRequest } from '@fluidframework/core-interfaces';
 import { IResponse } from '@fluidframework/core-interfaces';
-import { IRuntime } from '@fluidframework/container-definitions';
+import { IRuntime } from '@fluidframework/container-definitions/internal';
 import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
 import { ISignalMessage } from '@fluidframework/protocol-definitions';
 import { ISnapshotTree } from '@fluidframework/protocol-definitions';
-import { ISummarizerNodeWithGC } from '@fluidframework/runtime-definitions';
+import { ISummarizeResult } from '@fluidframework/runtime-definitions/internal';
+import { ISummarizerNodeWithGC } from '@fluidframework/runtime-definitions/internal';
 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 { NamedFluidDataStoreRegistryEntries } from '@fluidframework/runtime-definitions';
-import { SummarizeInternalFn } from '@fluidframework/runtime-definitions';
+import { MonitoringContext } from '@fluidframework/telemetry-utils/internal';
+import { NamedFluidDataStoreRegistryEntries } from '@fluidframework/runtime-definitions/internal';
+import { SummarizeInternalFn } from '@fluidframework/runtime-definitions/internal';
 import { TypedEventEmitter } from '@fluid-internal/client-utils';
 
 // @internal
@@ -66,9 +75,96 @@ export const AllowInactiveRequestHeaderKey = "allowInactive";
 // @alpha
 export const AllowTombstoneRequestHeaderKey = "allowTombstone";
 
+// @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;
+    // (undocumented)
+    deleteChild(dataStoreId: string): void;
+    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 implements IFluidDataStoreFactory {
-    constructor(registryEntries: NamedFluidDataStoreRegistryEntries, provideEntryPoint: (runtime: IFluidDataStoreChannel) => Promise<FluidObject>);
+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)
@@ -102,6 +198,7 @@ export enum ContainerMessageType {
     BlobAttach = "blobAttach",
     // (undocumented)
     ChunkedOp = "chunkedOp",
+    DocumentSchemaChange = "schema",
     // (undocumented)
     FluidDataStoreOp = "component",
     GC = "GC",
@@ -112,7 +209,7 @@ 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, createIdCompressor: () => Promise<IIdCompressor & IIdCompressorCore>, idCompressorMode: IdCompressorMode, 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>, documentsSchemaController: DocumentsSchemaController, featureGatesForTelemetry: Record<string, boolean | number | undefined>, 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: {
@@ -133,7 +230,6 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents
         runSweep?: boolean;
         fullGC?: boolean;
     }, telemetryContext?: ITelemetryContext): Promise<IGCStats | undefined>;
-    protected compressorLoadInitiated: boolean;
     // (undocumented)
     get connected(): boolean;
     // (undocumented)
@@ -148,8 +244,6 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents
     // (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;
@@ -158,6 +252,14 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents
     // (undocumented)
     readonly disposeFn: (error?: ICriticalContainerError) => void;
     // (undocumented)
+    get documentSchema(): {
+        explicitSchemaControl?: true | undefined;
+        compressionLz4?: true | undefined;
+        idCompressorMode?: IdCompressorMode;
+        opGroupingEnabled?: true | undefined;
+        disallowedVersions?: string[] | undefined;
+    };
+    // (undocumented)
     enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult;
     ensureNoDataModelChanges<T>(callback: () => T): T;
     // (undocumented)
@@ -191,10 +293,13 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents
     }>;
     get idCompressor(): (IIdCompressor & IIdCompressorCore) | undefined;
     // (undocumented)
+    get idCompressorMode(): IdCompressorMode;
+    // (undocumented)
     get IFluidDataStoreRegistry(): IFluidDataStoreRegistry;
     // (undocumented)
     get IFluidHandleContext(): IFluidHandleContext;
     get isDirty(): boolean;
+    protected _loadIdCompressor: Promise<void> | undefined;
     static loadRuntime(params: {
         context: IContainerContext;
         registryEntries: NamedFluidDataStoreRegistryEntries;
@@ -212,6 +317,8 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents
     // (undocumented)
     notifyOpReplay(message: ISequencedDocumentMessage): Promise<void>;
     // (undocumented)
+    onSchemaChange(schema: IDocumentSchemaCurrent): void;
+    // (undocumented)
     readonly options: Record<string | number, any>;
     orderSequentially<T>(callback: () => T): T;
     // (undocumented)
@@ -225,12 +332,14 @@ 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)
     submitMessage(type: ContainerMessageType.FluidDataStoreOp | ContainerMessageType.Alias | ContainerMessageType.Attach, contents: any, localOpMetadata?: unknown): void;
-    submitSignal(type: string, content: any, targetClientId?: string): void;
+    submitSignal(type: string, content: unknown, targetClientId?: string): void;
     submitSummary(options: ISubmitSummaryOptions): Promise<SubmitSummaryResult>;
     summarize(options: {
         fullTree?: boolean;
@@ -245,7 +354,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>>;
@@ -258,11 +366,61 @@ export interface ContainerRuntimeMessage {
     type: ContainerMessageType;
 }
 
+// @alpha
+export const currentDocumentVersionSchema = 1;
+
+// @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 const disabledCompressionConfig: ICompressionRuntimeOptions;
+
+// @alpha
+export type DocumentSchemaValueType = string | string[] | true | number | undefined;
+
+// @alpha
+export class DocumentsSchemaController {
+    constructor(existing: boolean, documentMetadataSchema: IDocumentSchema | undefined, features: IDocumentSchemaFeatures, onSchemaChange: (schema: IDocumentSchemaCurrent) => void);
+    maybeSendSchemaMessage(): IDocumentSchemaChangeMessage | undefined;
+    // (undocumented)
+    onDisconnect(): void;
+    processDocumentSchemaOp(content: IDocumentSchemaChangeMessage, local: boolean, sequenceNumber: number): boolean;
+    // (undocumented)
+    sessionSchema: IDocumentSchemaCurrent;
+    // (undocumented)
+    summarizeDocumentSchema(refSeq: number): IDocumentSchemaCurrent | undefined;
+}
 
 // @alpha (undocumented)
 export type EnqueueSummarizeResult = (ISummarizeResults & {
@@ -275,6 +433,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(aliasedDataStores?: Set<string>): 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: unknown, 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);
@@ -371,8 +668,6 @@ export interface IChunkedOp {
     // (undocumented)
     originalMetadata?: Record<string, unknown>;
     // (undocumented)
-    originalType: MessageType | ContainerMessageType;
-    // (undocumented)
     totalChunks: number;
 }
 
@@ -410,8 +705,11 @@ export interface IContainerRuntimeMessageCompatDetails {
 // @alpha (undocumented)
 export interface IContainerRuntimeMetadata extends ICreateContainerMetadata, IGCMetadata {
     readonly disableIsolatedChannels?: true;
-    readonly idCompressorMode?: IdCompressorMode;
-    readonly message: ISummaryMetadataMessage | undefined;
+    // (undocumented)
+    readonly documentSchema?: IDocumentSchema;
+    readonly lastMessage?: ISummaryMetadataMessage;
+    // @deprecated (undocumented)
+    readonly message?: ISummaryMetadataMessage;
     // (undocumented)
     readonly summaryFormatVersion: 1;
     readonly summaryNumber?: number;
@@ -425,6 +723,7 @@ export interface IContainerRuntimeOptions {
     readonly enableGroupedBatching?: boolean;
     readonly enableOpReentryCheck?: boolean;
     readonly enableRuntimeIdCompressor?: IdCompressorMode;
+    readonly explicitSchemaControl?: boolean;
     readonly flushMode?: FlushMode;
     // (undocumented)
     readonly gcOptions?: IGCRuntimeOptions;
@@ -441,7 +740,42 @@ export interface ICreateContainerMetadata {
 }
 
 // @alpha
-export type IdCompressorMode = "on" | "delayed" | "off";
+export type IdCompressorMode = "on" | "delayed" | undefined;
+
+// @alpha
+export interface IDocumentSchema {
+    // (undocumented)
+    refSeq: number;
+    // (undocumented)
+    runtime: Record<string, DocumentSchemaValueType>;
+    // (undocumented)
+    version: number;
+}
+
+// @alpha
+export type IDocumentSchemaChangeMessage = IDocumentSchema;
+
+// @alpha
+export type IDocumentSchemaCurrent = {
+    version: 1;
+    refSeq: number;
+    runtime: {
+        [P in keyof IDocumentSchemaFeatures]?: IDocumentSchemaFeatures[P] extends boolean ? true : IDocumentSchemaFeatures[P];
+    };
+};
+
+// @alpha
+export interface IDocumentSchemaFeatures {
+    // (undocumented)
+    compressionLz4: boolean;
+    disallowedVersions: string[];
+    // (undocumented)
+    explicitSchemaControl: boolean;
+    // (undocumented)
+    idCompressorMode: IdCompressorMode;
+    // (undocumented)
+    opGroupingEnabled: boolean;
+}
 
 // @alpha
 export interface IEnqueueSummarizeOptions extends IOnDemandSummarizeOptions {
@@ -449,6 +783,45 @@ export interface IEnqueueSummarizeOptions extends IOnDemandSummarizeOptions {
     readonly override?: boolean;
 }
 
+// @internal (undocumented)
+export interface IFluidDataStoreContextEvents extends IEvent {
+    // (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;
@@ -494,6 +867,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;
@@ -545,6 +936,18 @@ 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;
 
@@ -749,6 +1152,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;
 
@@ -764,27 +1189,21 @@ export interface RecentlyAddedContainerRuntimeMessageDetails {
 }
 
 // @internal
-export enum RuntimeHeaders {
-    viaHandle = "viaHandle",
-    wait = "wait"
-}
-
-// @internal @deprecated (undocumented)
-export enum RuntimeMessage {
+export interface RuntimeHeaderData {
     // (undocumented)
-    Alias = "alias",
-    // (undocumented)
-    Attach = "attach",
-    // (undocumented)
-    BlobAttach = "blobAttach",
-    // (undocumented)
-    ChunkedOp = "chunkedOp",
+    allowInactive?: boolean;
     // (undocumented)
-    FluidDataStoreOp = "component",
+    allowTombstone?: boolean;
     // (undocumented)
-    Operation = "op",
+    viaHandle?: boolean;
     // (undocumented)
-    Rejoin = "rejoin"
+    wait?: boolean;
+}
+
+// @internal
+export enum RuntimeHeaders {
+    viaHandle = "viaHandle",
+    wait = "wait"
 }
 
 // @alpha