@fluidframework/container-runtime 2.0.0-dev-rc.2.0.0.246488 → 2.0.0-dev-rc.3.0.0.253463

package/lib/container-runtime-untrimmed.d.ts

@@ -1,50 +1,50 @@
-import { AliasResult } from '@fluidframework/runtime-definitions';
+import { AliasResult } from '@fluidframework/runtime-definitions/internal';
 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 { 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 { IContainerRuntimeBase } from '@fluidframework/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';
+import { IFluidParentContext } from '@fluidframework/runtime-definitions/internal';
 import { IGarbageCollectionData } from '@fluidframework/runtime-definitions';
-import { IGarbageCollectionDetailsBase } 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 { ISummarizeResult } from '@fluidframework/runtime-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';
@@ -55,9 +55,9 @@ 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 { 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';
 
 /**
@@ -288,6 +288,10 @@ export declare enum ContainerMessageType {
      * See the [IdCompressor README](./id-compressor/README.md) for more details.
      */
     IdAllocation = "idAllocation",
+    /**
+     * An op that changes document schema
+     */
+    DocumentSchemaChange = "schema",
     /**
      * Garbage collection specific op. This is sent by the summarizer client when GC runs. It's used to synchronize GC
      * state across all clients.
@@ -308,7 +312,7 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
     readonly logger: ITelemetryLoggerExt;
     private readonly _storage;
     private readonly createIdCompressor;
-    private readonly idCompressorMode;
+    private readonly documentsSchemaController;
     private readonly requestHandler?;
     private readonly summaryConfiguration;
     /**
@@ -358,9 +362,17 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
     get IFluidDataStoreRegistry(): IFluidDataStoreRegistry;
     private readonly _getAttachState;
     get attachState(): AttachState;
+    get documentSchema(): {
+        explicitSchemaControl?: true | undefined;
+        compressionLz4?: true | undefined;
+        idCompressorMode?: IdCompressorMode;
+        opGroupingEnabled?: true | undefined;
+        disallowedVersions?: string[] | undefined;
+    };
     private _idCompressor;
     private pendingIdCompressorOps;
     private readonly skipSavedCompressorOps;
+    get idCompressorMode(): IdCompressorMode;
     /**
      * See IContainerRuntimeBase.idCompressor() for details.
      */
@@ -369,7 +381,7 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * True if we have ID compressor loading in-flight (async operation). Useful only for
      * this.idCompressorMode === "delayed" mode
      */
-    protected compressorLoadInitiated: boolean;
+    protected _loadIdCompressor: Promise<void> | undefined;
     /**
      * See IContainerRuntimeBase.generateDocumentUniqueId() for details.
      */
@@ -500,7 +512,8 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      */
     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, 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);
+    onSchemaChange(schema: IDocumentSchemaCurrent): void;
     getCreateChildSummarizerNodeFn(id: string, createParam: CreateChildSummarizerNodeParam): (summarizeInternal: SummarizeInternalFn, getGCDataFn: (fullGC?: boolean) => Promise<IGarbageCollectionData>) => ISummarizerNodeWithGC;
     deleteChildSummarizerNode(id: string): void;
     makeLocallyVisible(): void;
@@ -558,6 +571,7 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      */
     private parseLocalOpContent;
     private applyStashedOp;
+    private loadIdCompressor;
     setConnectionState(connected: boolean, clientId?: string): void;
     private setConnectionStateCore;
     notifyOpReplay(message: ISequencedDocumentMessage): Promise<void>;
@@ -620,10 +634,10 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
     /**
      * Submits the signal to be sent to other clients.
      * @param type - Type of the signal.
-     * @param content - Content of the signal.
+     * @param content - Content of the signal. Should be a JSON serializable object or primitive.
      * @param targetClientId - When specified, the signal is only sent to the provided client id.
      */
-    submitSignal(type: string, content: any, targetClientId?: string): void;
+    submitSignal(type: string, content: unknown, targetClientId?: string): void;
     setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
     /**
      * Create a summary. Used when attaching or serializing a detached container.
@@ -829,6 +843,15 @@ export declare interface ContainerRuntimeMessage {
     compatDetails?: IContainerRuntimeMessageCompatDetails;
 }
 
+/**
+ * Current version known properties that define document schema
+ * This must be bumped whenever the format of document schema or protocol for changing the current document schema changes.
+ * Ex: adding a new configuration property (under IDocumentSchema.runtime) does not require changing this version.
+ * Ex: Changing the 'document schema acceptance' mechanism from convert-and-swap to one requiring consensus does require changing this version.
+ * @alpha
+ */
+export declare const currentDocumentVersionSchema = 1;
+
 /** @internal */
 export declare class DataStoreContexts implements Iterable<[string, FluidDataStoreContext]>, IDisposable {
     private readonly notBoundContexts;
@@ -900,6 +923,118 @@ export declare const DefaultSummaryConfiguration: ISummaryConfiguration;
  */
 export declare function detectOutboundReferences(address: string, contents: unknown, addedOutboundReference: (fromNodePath: string, toNodePath: string) => void): void;
 
+/** @alpha */
+export declare const disabledCompressionConfig: ICompressionRuntimeOptions;
+
+/**
+ * Descripe allowed type for properties in document schema.
+ * Please note that for all property types we should use undefined to indicate that particular capability is off.
+ * Using false, or some string value (like "off") will result in clients who do not understand that property failing, whereas
+ * we want them to continue to collaborate alongside clients who support that capability, but such capability is shipping dark for now.
+ * @alpha
+ */
+export declare type DocumentSchemaValueType = string | string[] | true | number | undefined;
+
+/**
+ * Controller of document schema.
+ *
+ * Recommended pre-reading: https://github.com/microsoft/FluidFramework/blob/main/packages/dds/SchemaVersioning.md
+ *
+ * This class manages current document schema and transitions between document schemas.
+ * At the moment, it only focuses on subset of document schema, specifically - how FluidFramework runtime serializes data
+ * (summary and op format), features & capabilities that a version of runtime has to support and understand in
+ * order to collaborate on a document.
+ * New features that modify document format have to be included in document schema definition.
+ * Usage of such features could only happen after document schema has been updated to reflect such feature.
+ *
+ * This formality allows clients that do not understand such features to fail right away when they observe
+ * document schema listing capabilities that such client does not understand.
+ * Old clients will fail in predictable way. This allows us to
+ * 1) Immediately see such issues and adjust if features are enabled too early, before changes have been saturated.
+ * 2) There is no way to get to 100% saturation with new code. Even if we have 99.99% saturation, there are
+ *    still 0.01% of clients who will fail. Failing early and predictably ensures they have no chance to limp along
+ *    and potentially corrupt the document. This is especially true for summarizer client, who could simply "undo"
+ *    changes it does not understands.
+ *
+ * It's important to note how it overlaps with feature gates and safe velocity.
+ * If new feature was in use, that resulted in a number of documents referencing such feature in document schema.
+ * But, developers (through code deployment or feature gates) could disable usage of such features.
+ * That will stop a process of further document schema changes (for documents that were not using such feature).
+ * And documents that already list such capability in their schema will continue to do so. Later ensures that old
+ * clients who do not understand such feature will continue to fail to open such documents, as such documents very
+ * likely contain data in a new format.
+ *
+ * Controller operates with 4 schemas:
+ * - document schema: whatever we loaded from summary metadata + ops. It follows eventuall consistency rules (i.e. like DDS).
+ * - desired schema - what client is asking for to have (i.e. all the desired settings, based on runtime options / feature gates).
+ * - session schema - current session schema. It's "and" of the above two schemas.
+ * - future schema - "or" of document and desires schemas.
+ *
+ * "or" & "and" operators are defined individually for each property. For Boolean properties it's literally &&, || operators.
+ * But for other properties it's more nuanced.
+ *
+ * Whenver document schema does not match future schema, controller will send an op that attempts to changs documents schema to
+ * future schema.
+ *
+ * Users of this class need to use DocumentsSchemaController.sessionSchema to determine what features can be used.
+ *
+ * There are two modes this class can operate:
+ * 1) Legacy mode. In such mode it does not issue any ops to change document schema. Any changes happen implicitly,
+ *    right away, and new features are available right away
+ * 2) Non-legacy mode. In such mode any changes to schema require an op roundtrip. This class will manage such transitions.
+ *    However code should assume that any new features that were not enabled in a given document will not be available
+ *    for a given session. That's because this session may never send any ops (including read-only documents). Or it may
+ *    fail to convert schema.
+ *    This class promises eventual movement forward. I.e. if new feature is allowed (let's say - through feature gates),
+ *    then eventually all documents that are modified will have that feature reflected in their schema. It could require
+ *    multiple reloads / new sessions to get there (depends on if code reacts to schema changes right away, or only consults
+ *    schema on document load).
+ *
+ * How schemas are changed (in non-legacy mode):
+ * If a client needs to change a schema, it will attempt to do so as part of normal ops sending process.
+ * Changes happen in CAS (Compare-and-swap) fashion, i.e. client tells current schema and schema it wants to change to.
+ * When a number of clients race to change a schema, then only one of them will win, all others will fail because they will
+ * reference old schema that is no longer in effect.
+ * Clients can retry, but current implementation is simply - they will not (and will rely on next session / reload to do
+ * recalc and decide if schema needs to be changed or not).
+ *
+ * @alpha
+ */
+export declare class DocumentsSchemaController {
+    private readonly onSchemaChange;
+    private explicitSchemaControl;
+    private sendOp;
+    private documentSchema;
+    private readonly desiredSchema;
+    private futureSchema;
+    sessionSchema: IDocumentSchemaCurrent;
+    /**
+     * Constructs DocumentsSchemaController that controls current schema and processes around it, including changes in schema.
+     * @param existing - Is the document existing document, or a new doc.
+     * @param documentMetadataSchema - current document's schema, if present.
+     * @param features - features of the document schema that current session wants to see enabled.
+     * @param onSchemaChange - callback that is called whenever schema is changed (not called on creation / load, only when processing document schema change ops)
+     */
+    constructor(existing: boolean, documentMetadataSchema: IDocumentSchema | undefined, features: IDocumentSchemaFeatures, onSchemaChange: (schema: IDocumentSchemaCurrent) => void);
+    summarizeDocumentSchema(refSeq: number): IDocumentSchemaCurrent | undefined;
+    /**
+     * Called by Container runtime whenever it is about to send some op.
+     * It gives opportunity for controller to issue its own ops - we do not want to send ops if there are no local changes in document.
+     * @returns Optional message to send.
+     */
+    maybeSendSchemaMessage(): IDocumentSchemaChangeMessage | undefined;
+    /**
+     * Process document schema change message
+     * Called by ContainerRuntime whenever it sees document schema messages.
+     * @param content - content of the message
+     * @param local - whether op is local
+     * @param sequenceNumber - sequence number of the op
+     * @returns - true if schema was accepted, otherwise false (rejected due to failed CAS)
+     */
+    processDocumentSchemaOp(content: IDocumentSchemaChangeMessage, local: boolean, sequenceNumber: number): boolean;
+    onDisconnect(): void;
+}
+
 /**
  * @alpha
  */
@@ -1118,10 +1253,10 @@ export declare abstract class FluidDataStoreContext extends TypedEventEmitter<IF
     /**
      * Submits the signal to be sent to other clients.
      * @param type - Type of the signal.
-     * @param content - Content of the signal.
+     * @param content - Content of the signal. Should be a JSON serializable object or primitive.
      * @param targetClientId - When specified, the signal is only sent to the provided client id.
      */
-    submitSignal(type: string, content: any, targetClientId?: string): void;
+    submitSignal(type: string, content: unknown, 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.
@@ -1296,7 +1431,6 @@ export declare interface IChunkedOp {
     chunkId: number;
     totalChunks: number;
     contents: string;
-    originalType: MessageType | ContainerMessageType;
     originalMetadata?: Record<string, unknown>;
     originalCompression?: string;
 }
@@ -1352,16 +1486,17 @@ export declare interface IContainerRuntimeMessageCompatDetails {
  */
 export declare interface IContainerRuntimeMetadata extends ICreateContainerMetadata, IGCMetadata {
     readonly summaryFormatVersion: 1;
+    /** @deprecated - used by old (prior to 2.0 RC3) runtimes */
+    readonly message?: ISummaryMetadataMessage;
     /** The last message processed at the time of summary. Only primitive property types are added to the summary. */
-    readonly message: ISummaryMetadataMessage | undefined;
+    readonly lastMessage?: ISummaryMetadataMessage;
     /** True if channels are not isolated in .channels subtrees, otherwise isolated. */
     readonly disableIsolatedChannels?: true;
     /** The summary number for a container's summary. Incremented on summaries throughout its lifetime. */
     readonly summaryNumber?: number;
     /** GUID to identify a document in telemetry */
     readonly telemetryDocumentId?: string;
-    /** True if the runtime IdCompressor is enabled */
-    readonly idCompressorMode?: IdCompressorMode;
+    readonly documentSchema?: IDocumentSchema;
 }
 
 /**
@@ -1395,7 +1530,7 @@ export declare interface IContainerRuntimeOptions {
      * If specified, when in FlushMode.TurnBased, if the size of the ops between JS turns exceeds this value,
      * an error will be thrown and the container will close.
      *
-     * If unspecified, the limit is 950 * 1024.
+     * If unspecified, the limit is 700Kb.
      *
      * 'Infinity' will disable any limit.
      *
@@ -1442,6 +1577,14 @@ export declare interface IContainerRuntimeOptions {
      * @experimental Not ready for use.
      */
     readonly enableGroupedBatching?: boolean;
+    /**
+     * When this property is set to true, it requires runtime to control is document schema properly through ops
+     * The benefit of this mode is that clients who do not understand schema will fail in predictable way, with predictable message,
+     * and will not attempt to limp along, which could cause data corruptions and crashes in random places.
+     * When this property is not set (or set to false), runtime operates in legacy mode, where new features (modifying document schema)
+     * are engaged as they become available, without giving legacy clients any chance to fail predictably.
+     */
+    readonly explicitSchemaControl?: boolean;
 }
 
 /**
@@ -1461,12 +1604,92 @@ export declare interface ICreateContainerMetadata {
  * "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").
+ * undefined - ID compressor is not loaded.
  * While IContainerRuntime.generateDocumentUniqueId() is available, it will produce long IDs that are do not compress well.
  *
  * @alpha
  */
-export declare type IdCompressorMode = "on" | "delayed" | "off";
+export declare type IdCompressorMode = "on" | "delayed" | undefined;
+
+/**
+ * Document schema information.
+ * Describes overall shape of document schema, including unknown (to this version) properties.
+ *
+ * Used by runtime to make a call if it can understand document schema.
+ * If it can't, it should not continue with document and immediately fail, preventing random (cryptic) failures
+ * down the road and potentially corrupting documents.
+ * For now this structure and appropriate interpretation / behavior is focused only on runtime features.
+ * In the future that could be interpolated to more areas, including DDSs used, and even possibly - application
+ * schema.
+ *
+ * Runtime will ignore any properties at the root that it does not understand (i.e. IDocumentSchema.app), but will
+ * stop (and fail session) on any unknown properties within "runtime" sub-tree.
+ *
+ * In most cases values preserved in the document will not dictate if such features should be enabled in a given session.
+ * I.e. if compression is mentioned in document schema, this means that runtime version that opens such document must know
+ * how to interpret such ops, but does not need to actually use compression itself. That said, some options could be
+ * sticky, i.e. influence feature selection for all runtimes opening a document. ID compression is one such example.
+ * Currently there is no mechanism to remove feature from this property bag, i.e. once compression was used, even if it's
+ * disabled (through feature gate or code deployment), all existing documents that used compression will continue to fail
+ * if opened by clients who do not support compression.
+ *
+ * For now we are limiting it to just plain properties, and only really simple types, but that can be changed in the future.
+ *
+ * @alpha
+ */
+export declare interface IDocumentSchema {
+    version: number;
+    refSeq: number;
+    runtime: Record<string, DocumentSchemaValueType>;
+}
+
+/**
+ * Content of the type=ContainerMessageType.DocumentSchemaChange ops.
+ * The meaning of refSeq field is different in such messages (compared to other usages of IDocumentSchemaCurrent)
+ * ContainerMessageType.DocumentSchemaChange messages use CAS (Compare-and-swap) semantics, and convey
+ * regSeq of last known schema change (known to a client proposing schema change).
+ * @see ContainerRuntimeDocumentSchemaMessage
+ * @alpha
+ */
+export declare type IDocumentSchemaChangeMessage = IDocumentSchema;
+
+/**
+ * Current document schema.
+ * @alpha
+ */
+export declare type IDocumentSchemaCurrent = {
+    version: 1;
+    refSeq: number;
+    runtime: {
+        [P in keyof IDocumentSchemaFeatures]?: IDocumentSchemaFeatures[P] extends boolean ? true : IDocumentSchemaFeatures[P];
+    };
+};
+
+/**
+ * Settings that this session would like to have, based on options and feature gates.
+ *
+ * WARNING: This type is used to infer IDocumentSchemaCurrent type!
+ * Any changes here (including renaming of properties) are potentially changing document format and should be considered carefully!
+ *
+ * @alpha
+ */
+export declare interface IDocumentSchemaFeatures {
+    explicitSchemaControl: boolean;
+    compressionLz4: boolean;
+    idCompressorMode: IdCompressorMode;
+    opGroupingEnabled: boolean;
+    /**
+     * List of disallowed versions of the runtime.
+     * This option is sticky. Once a version of runtime is added to this list (when supplied to DocumentsSchemaController's constructor)
+     * it will be added to the list of disallowed versions and stored in document metadata.
+     * Each runtime checks if its version is in this list on container open. If it is, it immediately exits with error message
+     * indicating to the user that this version is no longer supported.
+     * Currently there is no mechanism to remove version from this list. I.e. If it was once added to the list,
+     * it gets added to any document metadata (documents that gets open by this runtime) and there is no way to clear it from document's
+     * metadata.
+     */
+    disallowedVersions: string[];
+}
 
 /**
  * Options to use when enqueueing a summarize attempt.
@@ -2225,20 +2448,6 @@ export declare enum RuntimeHeaders {
     viaHandle = "viaHandle"
 }
 
-/**
- * @deprecated use ContainerRuntimeMessageType instead
- * @internal
- */
-export declare enum RuntimeMessage {
-    FluidDataStoreOp = "component",
-    Attach = "attach",
-    ChunkedOp = "chunkedOp",
-    BlobAttach = "blobAttach",
-    Rejoin = "rejoin",
-    Alias = "alias",
-    Operation = "op"
-}
-
 /**
  * The data in summarizer result when submit summary stage fails.
  * @alpha

package/lib/containerHandleContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"containerHandleContext.d.ts","sourceRoot":"","sources":["../src/containerHandleContext.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAG3F,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,qBAAa,2BAA4B,YAAW,mBAAmB;aAarD,IAAI,EAAE,MAAM;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO;aACR,YAAY,CAAC;IAd9B,IAAW,mBAAmB,SAE7B;IACD,SAAgB,YAAY,EAAE,MAAM,CAAC;IAErC;;;;;OAKG;gBAEc,IAAI,EAAE,MAAM,EACX,OAAO,EAAE,gBAAgB,EAC1B,YAAY,CAAC,iCAAqB;IAK5C,WAAW,IAAI,IAAI;IAI1B,IAAW,UAAU,YAEpB;IAEY,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;CAGjE"}
+{"version":3,"file":"containerHandleContext.d.ts","sourceRoot":"","sources":["../src/containerHandleContext.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAG3F,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,qBAAa,2BAA4B,YAAW,mBAAmB;aAarD,IAAI,EAAE,MAAM;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO;aACR,YAAY,CAAC;IAd9B,IAAW,mBAAmB,SAE7B;IACD,SAAgB,YAAY,EAAE,MAAM,CAAC;IAErC;;;;;OAKG;gBAEc,IAAI,EAAE,MAAM,EACX,OAAO,EAAE,gBAAgB,EAC1B,YAAY,CAAC,iCAAqB;IAK5C,WAAW,IAAI,IAAI;IAI1B,IAAW,UAAU,YAEpB;IAEY,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;CAGjE"}

package/lib/containerHandleContext.js

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 import { AttachState } from "@fluidframework/container-definitions";
-import { generateHandleContextPath } from "@fluidframework/runtime-utils";
+import { generateHandleContextPath } from "@fluidframework/runtime-utils/internal";
 export class ContainerFluidHandleContext {
     get IFluidHandleContext() {
         return this;

package/lib/containerHandleContext.js.map

@@ -1 +1 @@
-{"version":3,"file":"containerHandleContext.js","sourceRoot":"","sources":["../src/containerHandleContext.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAG1E,MAAM,OAAO,2BAA2B;IACvC,IAAW,mBAAmB;QAC7B,OAAO,IAAI,CAAC;IACb,CAAC;IAGD;;;;;OAKG;IACH,YACiB,IAAY,EACX,OAAyB,EAC1B,YAAkC;QAFlC,SAAI,GAAJ,IAAI,CAAQ;QACX,YAAO,GAAP,OAAO,CAAkB;QAC1B,iBAAY,GAAZ,YAAY,CAAsB;QAElD,IAAI,CAAC,YAAY,GAAG,yBAAyB,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;IACxE,CAAC;IAEM,WAAW;QACjB,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;IAC1E,CAAC;IAED,IAAW,UAAU;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,KAAK,WAAW,CAAC,QAAQ,CAAC;IAC1D,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,OAAiB;QAC3C,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IAC5C,CAAC;CACD","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { IFluidHandleContext, IRequest, IResponse } from \"@fluidframework/core-interfaces\";\nimport { AttachState } from \"@fluidframework/container-definitions\";\nimport { generateHandleContextPath } from \"@fluidframework/runtime-utils\";\nimport { ContainerRuntime } from \"./containerRuntime.js\";\n\nexport class ContainerFluidHandleContext implements IFluidHandleContext {\n\tpublic get IFluidHandleContext() {\n\t\treturn this;\n\t}\n\tpublic readonly absolutePath: string;\n\n\t/**\n\t * Creates a new ContainerFluidHandleContext.\n\t * @param path - The path to this handle relative to the routeContext.\n\t * @param runtime - The IRuntime object this context represents.\n\t * @param routeContext - The parent IFluidHandleContext that has a route to this handle.\n\t */\n\tconstructor(\n\t\tpublic readonly path: string,\n\t\tprivate readonly runtime: ContainerRuntime,\n\t\tpublic readonly routeContext?: IFluidHandleContext,\n\t) {\n\t\tthis.absolutePath = generateHandleContextPath(path, this.routeContext);\n\t}\n\n\tpublic attachGraph(): void {\n\t\tthrow new Error(\"can't attach container runtime form within container!\");\n\t}\n\n\tpublic get isAttached() {\n\t\treturn this.runtime.attachState !== AttachState.Detached;\n\t}\n\n\tpublic async resolveHandle(request: IRequest): Promise<IResponse> {\n\t\treturn this.runtime.resolveHandle(request);\n\t}\n}\n"]}
+{"version":3,"file":"containerHandleContext.js","sourceRoot":"","sources":["../src/containerHandleContext.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AAEpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AAInF,MAAM,OAAO,2BAA2B;IACvC,IAAW,mBAAmB;QAC7B,OAAO,IAAI,CAAC;IACb,CAAC;IAGD;;;;;OAKG;IACH,YACiB,IAAY,EACX,OAAyB,EAC1B,YAAkC;QAFlC,SAAI,GAAJ,IAAI,CAAQ;QACX,YAAO,GAAP,OAAO,CAAkB;QAC1B,iBAAY,GAAZ,YAAY,CAAsB;QAElD,IAAI,CAAC,YAAY,GAAG,yBAAyB,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;IACxE,CAAC;IAEM,WAAW;QACjB,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;IAC1E,CAAC;IAED,IAAW,UAAU;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,KAAK,WAAW,CAAC,QAAQ,CAAC;IAC1D,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,OAAiB;QAC3C,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IAC5C,CAAC;CACD","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { AttachState } from \"@fluidframework/container-definitions\";\nimport { IFluidHandleContext, IRequest, IResponse } from \"@fluidframework/core-interfaces\";\nimport { generateHandleContextPath } from \"@fluidframework/runtime-utils/internal\";\n\nimport { ContainerRuntime } from \"./containerRuntime.js\";\n\nexport class ContainerFluidHandleContext implements IFluidHandleContext {\n\tpublic get IFluidHandleContext() {\n\t\treturn this;\n\t}\n\tpublic readonly absolutePath: string;\n\n\t/**\n\t * Creates a new ContainerFluidHandleContext.\n\t * @param path - The path to this handle relative to the routeContext.\n\t * @param runtime - The IRuntime object this context represents.\n\t * @param routeContext - The parent IFluidHandleContext that has a route to this handle.\n\t */\n\tconstructor(\n\t\tpublic readonly path: string,\n\t\tprivate readonly runtime: ContainerRuntime,\n\t\tpublic readonly routeContext?: IFluidHandleContext,\n\t) {\n\t\tthis.absolutePath = generateHandleContextPath(path, this.routeContext);\n\t}\n\n\tpublic attachGraph(): void {\n\t\tthrow new Error(\"can't attach container runtime form within container!\");\n\t}\n\n\tpublic get isAttached() {\n\t\treturn this.runtime.attachState !== AttachState.Detached;\n\t}\n\n\tpublic async resolveHandle(request: IRequest): Promise<IResponse> {\n\t\treturn this.runtime.resolveHandle(request);\n\t}\n}\n"]}