@fluidframework/container-runtime 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.225277

package/dist/containerRuntime.d.ts

@@ -2,51 +2,32 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { EventEmitter } from "events";
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { FluidObject, IFluidHandle, IFluidHandleContext, IFluidRouter, IRequest, IResponse } from "@fluidframework/core-interfaces";
-import { IAudience, IFluidTokenProvider, IContainerContext, IDeltaManager, IRuntime, ICriticalContainerError, AttachState, ILoaderOptions, ISnapshotTreeWithBlobContents } from "@fluidframework/container-definitions";
+import { FluidObject, IFluidHandle, IFluidHandleContext, IRequest, IResponse, IProvideFluidHandleContext } from "@fluidframework/core-interfaces";
+import { IAudience, IContainerContext, IDeltaManager, IRuntime, ICriticalContainerError, AttachState, ILoaderOptions, IGetPendingLocalStateProps } from "@fluidframework/container-definitions";
 import { IContainerRuntime, IContainerRuntimeEvents } from "@fluidframework/container-runtime-definitions";
-import { TypedEventEmitter } from "@fluidframework/common-utils";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { IDocumentStorageService } from "@fluidframework/driver-definitions";
-import { IClientDetails, IDocumentMessage, IQuorumClients, ISequencedDocumentMessage, ISignalMessage, ISnapshotTree, ISummaryTree, MessageType } from "@fluidframework/protocol-definitions";
+import { IClientDetails, IDocumentMessage, IQuorumClients, ISequencedDocumentMessage, ISignalMessage, ISummaryTree, MessageType } from "@fluidframework/protocol-definitions";
 import { FlushMode, IFluidDataStoreContextDetached, IFluidDataStoreRegistry, IGarbageCollectionData, NamedFluidDataStoreRegistryEntries, ISummaryTreeWithStats, IDataStore, ITelemetryContext } from "@fluidframework/runtime-definitions";
+import type { IIdCompressor, IIdCompressorCore, SerializedIdCompressorWithOngoingSession } from "@fluidframework/id-compressor";
 import { IPendingLocalState } from "./pendingStateManager";
-import { SubmitSummaryResult, ISubmitSummaryOptions, ISummarizer, ISummarizerInternalsProvider, ISummarizerOptions, ISummarizerRuntime } from "./summarizerTypes";
-import { GCNodeType, IGarbageCollectionRuntime, IGCStats } from "./garbageCollection";
-import { ISerializedBaseSnapshotBlobs } from "./serializedSnapshotStorage";
-export declare enum ContainerMessageType {
-    FluidDataStoreOp = "component",
-    Attach = "attach",
-    ChunkedOp = "chunkedOp",
-    BlobAttach = "blobAttach",
-    Rejoin = "rejoin",
-    Alias = "alias"
-}
-export interface IChunkedOp {
-    chunkId: number;
-    totalChunks: number;
-    contents: string;
-    originalType: MessageType | ContainerMessageType;
-}
-export interface ContainerRuntimeMessage {
-    contents: any;
-    type: ContainerMessageType;
-}
+import { IBlobManagerLoadInfo, IPendingBlobs } from "./blobManager";
+import { IContainerRuntimeMetadata, ISerializedElection, SubmitSummaryResult, ISubmitSummaryOptions, ISummarizerInternalsProvider, ISummarizerRuntime, IRefreshSummaryAckOptions, IOnDemandSummarizeOptions, ISummarizeResults, IEnqueueSummarizeOptions, EnqueueSummarizeResult, ISummarizerEvents } from "./summary";
+import { GCNodeType, IGCRuntimeOptions, IGCStats } from "./gc";
+import { IBatch } from "./opLifecycle";
+/**
+ * @alpha
+ */
 export interface ISummaryBaseConfiguration {
     /**
-     *  Delay before first attempt to spawn summarizing container.
+     * Delay before first attempt to spawn summarizing container.
      */
     initialSummarizerDelayMs: number;
-    /**
-     * Flag that will enable changing elected summarizer client after maxOpsSinceLastSummary.
-     * This defaults to false (disabled) and must be explicitly set to true to enable.
-     */
-    summarizerClientElection: boolean;
     /**
      * Defines the maximum allowed time to wait for a pending summary ack.
      * The maximum amount of time client will wait for a summarize is the minimum of
-     * maxSummarizeAckWaitTime (currently 10 * 60 * 1000) and maxAckWaitTime.
+     * maxSummarizeAckWaitTime (currently 3 * 60 * 1000) and maxAckWaitTime.
      */
     maxAckWaitTime: number;
     /**
@@ -55,15 +36,16 @@ export interface ISummaryBaseConfiguration {
      */
     maxOpsSinceLastSummary: number;
 }
+/**
+ * @alpha
+ */
 export interface ISummaryConfigurationHeuristics extends ISummaryBaseConfiguration {
     state: "enabled";
     /**
-     * Defines the maximum allowed time in between summarizations.
-     */
-    idleTime: number;
-    /**
-     * Defines the maximum allowed time, since the last received Ack,  before running the summary
+     * Defines the maximum allowed time, since the last received Ack, before running the summary
      * with reason maxTime.
+     * For example, say we receive ops one by one just before the idle time is triggered.
+     * In this case, we still want to run a summary since it's been a while since the last summary.
      */
     maxTime: number;
     /**
@@ -76,78 +58,98 @@ export interface ISummaryConfigurationHeuristics extends ISummaryBaseConfigurati
      * before running the last summary.
      */
     minOpsForLastSummaryAttempt: number;
-}
-export interface ISummaryConfigurationDisableSummarizer {
-    state: "disabled";
-}
-export interface ISummaryConfigurationDisableHeuristics extends ISummaryBaseConfiguration {
-    state: "disableHeuristics";
-}
-export declare type ISummaryConfiguration = ISummaryConfigurationDisableSummarizer | ISummaryConfigurationDisableHeuristics | ISummaryConfigurationHeuristics;
-export declare const DefaultSummaryConfiguration: ISummaryConfiguration;
-export interface IGCRuntimeOptions {
     /**
-     * Flag that if true, will enable running garbage collection (GC) in a container. GC has mark phase and sweep phase.
-     * In mark phase, unreferenced objects are identified and marked as such in the summary. This option enables the
-     * mark phase.
-     * In sweep phase, unreferenced objects are eventually deleted from the container if they meet certain conditions.
-     * Sweep phase can be enabled via the "sweepAllowed" option.
-     * Note: This setting becomes part of the container's summary and cannot be changed.
+     * Defines the lower boundary for the allowed time in between summarizations.
+     * Pairs with maxIdleTime to form a range.
+     * For example, if we only receive 1 op, we don't want to have the same idle time as say 100 ops.
+     * Based on the boundaries we set in minIdleTime and maxIdleTime, the idle time will change
+     * linearly depending on the number of ops we receive.
      */
-    gcAllowed?: boolean;
+    minIdleTime: number;
     /**
-     * Flag that if true, enables GC's sweep phase which will eventually delete unreferenced objects from the container.
-     * This flag should only be set to true if "gcAllowed" is true.
-     * Note: This setting becomes part of the container's summary and cannot be changed.
+     * Defines the upper boundary for the allowed time in between summarizations.
+     * Pairs with minIdleTime to form a range.
+     * For example, if we only receive 1 op, we don't want to have the same idle time as say 100 ops.
+     * Based on the boundaries we set in minIdleTime and maxIdleTime, the idle time will change
+     * linearly depending on the number of ops we receive.
      */
-    sweepAllowed?: boolean;
+    maxIdleTime: number;
     /**
-     * Flag that will disable garbage collection if set to true. Can be used to disable running GC on container where
-     * is allowed via the gcAllowed option.
+     * Runtime op weight to use in heuristic summarizing.
+     * This number is a multiplier on the number of runtime ops we process when running summarize heuristics.
+     * For example: (multiplier) * (number of runtime ops) = weighted number of runtime ops
      */
-    disableGC?: boolean;
+    runtimeOpWeight: number;
     /**
-     * Flag that will bypass optimizations and generate GC data for all nodes irrespective of whether a node
-     * changed or not.
+     * Non-runtime op weight to use in heuristic summarizing
+     * This number is a multiplier on the number of non-runtime ops we process when running summarize heuristics.
+     * For example: (multiplier) * (number of non-runtime ops) = weighted number of non-runtime ops
      */
-    runFullGC?: boolean;
+    nonRuntimeOpWeight: number;
     /**
-     * Allows additional GC options to be passed.
+     * Number of ops since last summary needed before a non-runtime op can trigger running summary heuristics.
+     *
+     * Note: Any runtime ops sent before the threshold is reached will trigger heuristics normally.
+     * This threshold ONLY applies to non-runtime ops triggering summaries.
+     *
+     * For example: Say the threshold is 20. Sending 19 non-runtime ops will not trigger any heuristic checks.
+     * Sending the 20th non-runtime op will trigger the heuristic checks for summarizing.
      */
-    [key: string]: any;
+    nonRuntimeHeuristicThreshold?: number;
 }
+/**
+ * @alpha
+ */
+export interface ISummaryConfigurationDisableSummarizer {
+    state: "disabled";
+}
+/**
+ * @alpha
+ */
+export interface ISummaryConfigurationDisableHeuristics extends ISummaryBaseConfiguration {
+    state: "disableHeuristics";
+}
+/**
+ * @alpha
+ */
+export type ISummaryConfiguration = ISummaryConfigurationDisableSummarizer | ISummaryConfigurationDisableHeuristics | ISummaryConfigurationHeuristics;
+/**
+ * @alpha
+ */
+export declare const DefaultSummaryConfiguration: ISummaryConfiguration;
+/**
+ * @alpha
+ */
 export interface ISummaryRuntimeOptions {
     /** Override summary configurations set by the server. */
     summaryConfigOverrides?: ISummaryConfiguration;
-    disableIsolatedChannels?: boolean;
     /**
-     *  @deprecated - use `summaryConfigOverrides.initialSummarizerDelayMs` instead.
-     *  Delay before first attempt to spawn summarizing container.
-    */
+     * Delay before first attempt to spawn summarizing container.
+     *
+     * @deprecated Use {@link ISummaryRuntimeOptions.summaryConfigOverrides}'s
+     * {@link ISummaryBaseConfiguration.initialSummarizerDelayMs} instead.
+     */
     initialSummarizerDelayMs?: number;
+}
+/**
+ * Options for op compression.
+ * @alpha
+ */
+export interface ICompressionRuntimeOptions {
     /**
-     * @deprecated - use `summaryConfigOverrides.disableSummaries` instead.
-     * Flag that disables summaries if it is set to true.
+     * The value the batch's content size must exceed for the batch to be compressed.
+     * By default the value is 600 * 1024 = 614400 bytes. If the value is set to `Infinity`, compression will be disabled.
      */
-    disableSummaries?: boolean;
+    readonly minimumBatchSizeInBytes: number;
     /**
-     * @deprecated - use `summaryConfigOverrides.maxOpsSinceLastSummary` instead.
-     * Defaults to 7000 ops
+     * The compression algorithm that will be used to compress the op.
+     * By default the value is `lz4` which is the only compression algorithm currently supported.
      */
-    maxOpsSinceLastSummary?: number;
-    /**
-    * @deprecated - use `summaryConfigOverrides.summarizerClientElection` instead.
-    * Flag that will enable changing elected summarizer client after maxOpsSinceLastSummary.
-    * This defaults to false (disabled) and must be explicitly set to true to enable.
-    */
-    summarizerClientElection?: boolean;
-    /**
-     * @deprecated - use `summaryConfigOverrides.state = "DisableHeuristics"` instead.
-     *  Options that control the running summarizer behavior. */
-    summarizerOptions?: Readonly<Partial<ISummarizerOptions>>;
+    readonly compressionAlgorithm: CompressionAlgorithms;
 }
 /**
  * Options for container runtime.
+ * @alpha
  */
 export interface IContainerRuntimeOptions {
     readonly summaryOptions?: ISummaryRuntimeOptions;
@@ -161,12 +163,6 @@ export interface IContainerRuntimeOptions {
      * 3. "bypass" will skip the check entirely. This is not recommended.
      */
     readonly loadSequenceNumberVerification?: "close" | "log" | "bypass";
-    /**
-     * Should the runtime use data store aliasing for creating root datastores.
-     * In case of aliasing conflicts, the runtime will raise an exception which does
-     * not effect the status of the container.
-     */
-    readonly useDataStoreAliasing?: boolean;
     /**
      * Sets the flush mode for the runtime. In Immediate flush mode the runtime will immediately
      * send all operations to the driver layer, while in TurnBased the operations will be buffered
@@ -175,31 +171,108 @@ export interface IContainerRuntimeOptions {
      */
     readonly flushMode?: FlushMode;
     /**
-     * Save enough runtime state to be able to serialize upon request and load to the same state in a new container.
+     * Enables the runtime to compress ops. See {@link ICompressionRuntimeOptions}.
      */
-    readonly enableOfflineLoad?: boolean;
-}
-/**
- * The summary tree returned by the root node. It adds state relevant to the root of the tree.
- */
-export interface IRootSummaryTreeWithStats extends ISummaryTreeWithStats {
-    /** The garbage collection stats if GC ran, undefined otherwise. */
-    gcStats?: IGCStats;
+    readonly compressionOptions?: ICompressionRuntimeOptions;
+    /**
+     * 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.
+     *
+     * 'Infinity' will disable any limit.
+     *
+     * @experimental This config should be driven by the connection with the service and will be moved in the future.
+     */
+    readonly maxBatchSizeInBytes?: number;
+    /**
+     * If the op payload needs to be chunked in order to work around the maximum size of the batch, this value represents
+     * how large the individual chunks will be. This is only supported when compression is enabled. If after compression, the
+     * batch content size exceeds this value, it will be chunked into smaller ops of this exact size.
+     *
+     * This value is a trade-off between having many small chunks vs fewer larger chunks and by default, the runtime is configured to use
+     * 200 * 1024 = 204800 bytes. This default value ensures that no compressed payload's content is able to exceed {@link IContainerRuntimeOptions.maxBatchSizeInBytes}
+     * regardless of the overhead of an individual op.
+     *
+     * Any value of `chunkSizeInBytes` exceeding {@link IContainerRuntimeOptions.maxBatchSizeInBytes} will disable this feature, therefore if a compressed batch's content
+     * size exceeds {@link IContainerRuntimeOptions.maxBatchSizeInBytes} after compression, the container will close with an instance of `GenericError` with
+     * the `BatchTooLarge` message.
+     */
+    readonly chunkSizeInBytes?: number;
+    /**
+     * Enable the IdCompressor in the runtime.
+     * @experimental Not ready for use.
+     */
+    readonly enableRuntimeIdCompressor?: boolean;
+    /**
+     * If enabled, the runtime will block all attempts to send an op inside the
+     * {@link ContainerRuntime#ensureNoDataModelChanges} callback. The callback is used by
+     * {@link @fluidframework/shared-object-base#SharedObjectCore} for event handlers so enabling this
+     * will disallow modifying DDSes while handling DDS events.
+     *
+     * By default, the feature is disabled. If enabled from options, the `Fluid.ContainerRuntime.DisableOpReentryCheck`
+     * can be used to disable it at runtime.
+     */
+    readonly enableOpReentryCheck?: boolean;
+    /**
+     * If enabled, the runtime will group messages within a batch into a single
+     * message to be sent to the service.
+     * The grouping an ungrouping of such messages is handled by the "OpGroupingManager".
+     *
+     * By default, the feature is disabled. If enabled from options, the `Fluid.ContainerRuntime.DisableGroupedBatching`
+     * flag can be used to disable it at runtime.
+     *
+     * @experimental Not ready for use.
+     */
+    readonly enableGroupedBatching?: boolean;
 }
 /**
  * Accepted header keys for requests coming to the runtime.
+ * @internal
  */
 export declare enum RuntimeHeaders {
     /** True to wait for a data store to be created and loaded before returning it. */
     wait = "wait",
-    /**
-     * True if the request is from an external app. Used for GC to handle scenarios where a data store
-     * is deleted and requested via an external app.
-     */
-    externalRequest = "externalRequest",
     /** True if the request is coming from an IFluidHandle. */
     viaHandle = "viaHandle"
 }
+/** True if a tombstoned object should be returned without erroring
+ * @alpha
+ */
+export declare const AllowTombstoneRequestHeaderKey = "allowTombstone";
+/**
+ * [IRRELEVANT IF throwOnInactiveLoad OPTION NOT SET] True if an inactive object should be returned without erroring
+ * @internal
+ */
+export declare const AllowInactiveRequestHeaderKey = "allowInactive";
+/**
+ * Tombstone error responses will have this header set to true
+ * @alpha
+ */
+export declare const TombstoneResponseHeaderKey = "isTombstoned";
+/**
+ * Inactive error responses will have this header set to true
+ * @alpha
+ */
+export declare const InactiveResponseHeaderKey = "isInactive";
+/**
+ * The full set of parsed header data that may be found on Runtime requests
+ */
+export interface RuntimeHeaderData {
+    wait?: boolean;
+    viaHandle?: boolean;
+    allowTombstone?: boolean;
+    allowInactive?: boolean;
+}
+/** Default values for Runtime Headers */
+export declare const defaultRuntimeHeaderData: Required<RuntimeHeaderData>;
+/**
+ * Available compression algorithms for op compression.
+ * @alpha
+ */
+export declare enum CompressionAlgorithms {
+    lz4 = "lz4"
+}
 /**
  * State saved when the container closes, to be given back to a newly
  * instantiated runtime in a new instance of the container, so it can load to the
@@ -211,21 +284,22 @@ export interface IPendingRuntimeState {
      */
     pending?: IPendingLocalState;
     /**
-     * A base snapshot at a sequence number prior to the first pending op
-     */
-    baseSnapshot: ISnapshotTree;
-    /**
-     * Serialized blobs from the base snapshot. Used to load offline since
-     * storage is not available.
+     * Pending blobs from BlobManager
      */
-    snapshotBlobs: ISerializedBaseSnapshotBlobs;
+    pendingAttachmentBlobs?: IPendingBlobs;
     /**
-     * All runtime ops since base snapshot sequence number up to the latest op
-     * seen when the container was closed. Used to apply stashed (saved pending)
-     * ops at the same sequence number at which they were made.
+     * Pending idCompressor state
      */
-    savedOps: ISequencedDocumentMessage[];
+    pendingIdCompressorState?: SerializedIdCompressorWithOngoingSession;
 }
+/** The default time to wait for pending ops to be processed during summarization */
+export declare const defaultPendingOpsWaitTimeoutMs = 1000;
+/** The default time to delay a summarization retry attempt when there are pending ops */
+export declare const defaultPendingOpsRetryDelayMs = 1000;
+/**
+ * @deprecated use ContainerRuntimeMessageType instead
+ * @internal
+ */
 export declare enum RuntimeMessage {
     FluidDataStoreOp = "component",
     Attach = "attach",
@@ -235,30 +309,16 @@ export declare enum RuntimeMessage {
     Alias = "alias",
     Operation = "op"
 }
-export declare function isRuntimeMessage(message: ISequencedDocumentMessage): boolean;
-export declare function unpackRuntimeMessage(message: ISequencedDocumentMessage): ISequencedDocumentMessage;
 /**
- * This class has the following responsibilities:
- * 1. It tracks batches as we process ops and raises "batchBegin" and "batchEnd" events.
- *    As part of it, it validates batch correctness (i.e. no system ops in the middle of batch)
- * 2. It creates instance of ScheduleManagerCore that ensures we never start processing ops from batch
- *    unless all ops of the batch are in.
+ * @deprecated please use version in driver-utils
+ * @internal
  */
-export declare class ScheduleManager {
-    private readonly deltaManager;
-    private readonly emitter;
-    private readonly logger;
-    private readonly deltaScheduler;
-    private batchClientId;
-    private hitError;
-    constructor(deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>, emitter: EventEmitter, logger: ITelemetryLogger);
-    beforeOpProcessing(message: ISequencedDocumentMessage): void;
-    afterOpProcessing(error: any | undefined, message: ISequencedDocumentMessage): void;
-}
+export declare function isRuntimeMessage(message: ISequencedDocumentMessage): boolean;
 /**
  * Legacy ID for the built-in AgentScheduler.  To minimize disruption while removing it, retaining this as a
  * special-case for document dirty state.  Ultimately we should have no special-cases from the
  * ContainerRuntime's perspective.
+ * @internal
  */
 export declare const agentSchedulerId = "_scheduler";
 export declare function getDeviceSpec(): {
@@ -268,43 +328,86 @@ export declare function getDeviceSpec(): {
     deviceMemory?: undefined;
     hardwareConcurrency?: undefined;
 };
+/**
+ * Older loader doesn't have a submitBatchFn member, this is the older way of submitting a batch.
+ * Rather than exposing the submitFn (now deprecated) and IDeltaManager (dangerous to hand out) to the Outbox,
+ * we can provide a partially-applied function to keep those items private to the ContainerRuntime.
+ */
+export declare const makeLegacySendBatchFn: (submitFn: (type: MessageType, contents: any, batch: boolean, appData?: any) => number, deltaManager: Pick<IDeltaManager<unknown, unknown>, "flush">) => (batch: IBatch) => void;
 /**
  * Represents the runtime of the container. Contains helper functions/state of the container.
  * It will define the store level mappings.
+ * @alpha
  */
-export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents> implements IContainerRuntime, IGarbageCollectionRuntime, IRuntime, ISummarizerRuntime, ISummarizerInternalsProvider {
-    private readonly context;
+export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents & ISummarizerEvents> implements IContainerRuntime, IRuntime, ISummarizerRuntime, ISummarizerInternalsProvider, IProvideFluidHandleContext {
     private readonly registry;
     private readonly runtimeOptions;
     private readonly containerScope;
-    readonly logger: ITelemetryLogger;
+    readonly logger: ITelemetryLoggerExt;
     private readonly _storage;
     private readonly requestHandler?;
     private readonly summaryConfiguration;
-    get IContainerRuntime(): this;
-    get IFluidRouter(): this;
     /**
      * Load the stores from a snapshot and returns the runtime.
-     * @param context - Context of the container.
-     * @param registryEntries - Mapping to the stores.
-     * @param requestHandler - Request handlers for the container runtime
-     * @param runtimeOptions - Additional options to be passed to the runtime
-     * @param existing - (optional) When loading from an existing snapshot. Precedes context.existing if provided
-     */
-    static load(context: IContainerContext, registryEntries: NamedFluidDataStoreRegistryEntries, requestHandler?: (request: IRequest, runtime: IContainerRuntime) => Promise<IResponse>, runtimeOptions?: IContainerRuntimeOptions, containerScope?: FluidObject, existing?: boolean): Promise<ContainerRuntime>;
-    get options(): ILoaderOptions;
+     * @param params - An object housing the runtime properties:
+     * - context - Context of the container.
+     * - registryEntries - Mapping from data store types to their corresponding factories.
+     * - existing - Pass 'true' if loading from an existing snapshot.
+     * - requestHandler - (optional) Request handler for the request() method of the container runtime.
+     * Only relevant for back-compat while we remove the request() method and move fully to entryPoint as the main pattern.
+     * - runtimeOptions - Additional options to be passed to the runtime
+     * - containerScope - runtime services provided with context
+     * - containerRuntimeCtor - Constructor to use to create the ContainerRuntime instance.
+     * This allows mixin classes to leverage this method to define their own async initializer.
+     * - provideEntryPoint - Promise that resolves to an object which will act as entryPoint for the Container.
+     * This object should provide all the functionality that the Container is expected to provide to the loader layer.
+     */
+    static loadRuntime(params: {
+        context: IContainerContext;
+        registryEntries: NamedFluidDataStoreRegistryEntries;
+        existing: boolean;
+        runtimeOptions?: IContainerRuntimeOptions;
+        containerScope?: FluidObject;
+        containerRuntimeCtor?: typeof ContainerRuntime;
+        /** @deprecated Will be removed once Loader LTS version is "2.0.0-internal.7.0.0". Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md */
+        requestHandler?: (request: IRequest, runtime: IContainerRuntime) => Promise<IResponse>;
+        provideEntryPoint: (containerRuntime: IContainerRuntime) => Promise<FluidObject>;
+    }): Promise<ContainerRuntime>;
+    readonly options: ILoaderOptions;
+    private imminentClosure;
+    private readonly _getClientId;
     get clientId(): string | undefined;
-    get clientDetails(): IClientDetails;
-    get deltaManager(): IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    readonly clientDetails: IClientDetails;
     get storage(): IDocumentStorageService;
-    get reSubmitFn(): (type: ContainerMessageType, content: any, localOpMetadata: unknown, opMetadata: Record<string, unknown> | undefined) => void;
-    get closeFn(): (error?: ICriticalContainerError) => void;
+    private readonly submitFn;
+    /**
+     * Although current IContainerContext guarantees submitBatchFn, it is not available on older loaders.
+     */
+    private readonly submitBatchFn;
+    private readonly submitSummaryFn;
+    private readonly submitSignalFn;
+    readonly disposeFn: (error?: ICriticalContainerError) => void;
+    readonly closeFn: (error?: ICriticalContainerError) => void;
     get flushMode(): FlushMode;
     get scope(): FluidObject;
     get IFluidDataStoreRegistry(): IFluidDataStoreRegistry;
+    private readonly _getAttachState;
     get attachState(): AttachState;
+    idCompressor: (IIdCompressor & IIdCompressorCore) | undefined;
     get IFluidHandleContext(): IFluidHandleContext;
     private readonly handleContext;
+    /**
+     * This is a proxy to the delta manager provided by the container context (innerDeltaManager). It restricts certain
+     * accesses such as sets "read-only" mode for the summarizer client. This is the default delta manager that should
+     * be used unless the innerDeltaManager is required.
+     */
+    readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    /**
+     * The delta manager provided by the container context. By default, using the default delta manager (proxy)
+     * should be sufficient. This should be used only if necessary. For example, for validating and propagating connected
+     * events which requires access to the actual real only info, this is needed.
+     */
+    private readonly innerDeltaManager;
     private readonly mc;
     private readonly summarizerClientElection?;
     /**
@@ -315,18 +418,35 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
     private readonly summaryManager?;
     private readonly summaryCollection;
     private readonly summarizerNode;
-    private readonly _aliasingEnabled;
-    private readonly _maxOpSizeInBytes;
     private readonly maxConsecutiveReconnects;
     private readonly defaultMaxConsecutiveReconnects;
     private _orderSequentiallyCalls;
-    private _flushMode;
-    private needsFlush;
-    private flushTrigger;
+    private readonly _flushMode;
+    private flushTaskExists;
     private _connected;
-    private readonly savedOps;
-    private baseSnapshotBlobs?;
     private consecutiveReconnects;
+    /**
+     * Used to delay transition to "connected" state while we upload
+     * attachment blobs that were added while disconnected
+     */
+    private delayConnectClientId?;
+    private ensureNoDataModelChangesCalls;
+    /**
+     * Tracks the number of detected reentrant ops to report,
+     * in order to self-throttle the telemetry events.
+     *
+     * This should be removed as part of ADO:2322
+     */
+    private opReentryCallsToReport;
+    /**
+     * Invokes the given callback and expects that no ops are submitted
+     * until execution finishes. If an op is submitted, an error will be raised.
+     *
+     * Can be disabled by feature gate `Fluid.ContainerRuntime.DisableOpReentryCheck`
+     *
+     * @param callback - the callback to be invoked
+     */
+    ensureNoDataModelChanges<T>(callback: () => T): T;
     get connected(): boolean;
     /** clientId of parent (non-summarizing) container that owns summarizer container */
     get summarizerClientId(): string | undefined;
@@ -334,27 +454,30 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
     get disposed(): boolean;
     private dirtyContainer;
     private emitDirtyDocumentEvent;
+    private readonly enableOpReentryCheck;
+    private readonly disableAttachReorder;
+    private readonly closeSummarizerDelayMs;
+    /**
+     * If true, summary generated is validate before uploading it to the server. With single commit summaries,
+     * summaries will be accepted once uploaded, so they should be validated before upload. However, this can
+     * currently be controlled via a feature flag as its a new functionality.
+     */
+    private readonly validateSummaryBeforeUpload;
     private readonly defaultTelemetrySignalSampleCount;
-    private _perfSignalData;
+    private readonly _perfSignalData;
     /**
      * Summarizer is responsible for coordinating when to send generate and send summaries.
      * It is the main entry point for summary work.
      * It is created only by summarizing container (i.e. one with clientType === "summarizer")
      */
     private readonly _summarizer?;
-    private readonly deltaSender;
     private readonly scheduleManager;
     private readonly blobManager;
     private readonly pendingStateManager;
+    private readonly outbox;
     private readonly garbageCollector;
-    private readonly chunkMap;
     private readonly dataStores;
-    /**
-     * True if generating summaries with isolated channels is
-     * explicitly disabled. This only affects how summaries are written,
-     * and is the single source of truth for this container.
-     */
-    readonly disableIsolatedChannels: boolean;
+    private readonly remoteMessageProcessor;
     /** The last message processed at the time of the last summary. */
     private messageAtLastSummary;
     private get summarizer();
@@ -362,8 +485,6 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
     private isSummariesDisabled;
     private readonly heuristicsDisabled;
     private isHeuristicsDisabled;
-    private readonly summarizerClientElectionEnabled;
-    private isSummarizerClientElectionEnabled;
     private readonly maxOpsSinceLastSummary;
     private getMaxOpsSinceLastSummary;
     private readonly initialSummarizerDelayMs;
@@ -374,80 +495,113 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * a summary is generated.
      */
     private nextSummaryNumber;
-    private readonly opTracker;
-    private constructor();
+    /** If false, loading or using a Tombstoned object should merely log, not fail */
+    get gcTombstoneEnforcementAllowed(): boolean;
+    /** If true, throw an error when a tombstone data store is used. */
+    get gcThrowOnTombstoneUsage(): boolean;
+    /**
+     * GUID to identify a document in telemetry
+     * ! Note: should not be used for anything other than telemetry and is not considered a stable GUID
+     */
+    private readonly telemetryDocumentId;
+    /**
+     * If true, the runtime has access to an IdCompressor
+     */
+    private readonly idCompressorEnabled;
+    /**
+     * Whether this client is the summarizer client itself (type is summarizerClientType)
+     */
+    private readonly isSummarizerClient;
+    /**
+     * The id of the version used to initially load this runtime, or undefined if it's newly created.
+     */
+    private readonly loadedFromVersionId;
+    /***/
+    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);
+    /**
+     * Initializes the state from the base snapshot this container runtime loaded from.
+     */
+    private initializeBaseState;
     dispose(error?: Error): void;
-    get IFluidTokenProvider(): IFluidTokenProvider | undefined;
     /**
      * Notifies this object about the request made to the container.
      * @param request - Request made to the handler.
+     * @deprecated Will be removed in future major release. This method needs to stay private until LTS version of Loader moves to "2.0.0-internal.7.0.0".
      */
-    request(request: IRequest): Promise<IResponse>;
+    private request;
     /**
      * Resolves URI representing handle
      * @param request - Request made to the handler.
      */
     resolveHandle(request: IRequest): Promise<IResponse>;
+    /**
+     * {@inheritDoc @fluidframework/container-definitions#IRuntime.getEntryPoint}
+     */
+    getEntryPoint(): Promise<FluidObject>;
+    private readonly entryPoint;
     private internalId;
     private getDataStoreFromRequest;
     /** Adds the container's metadata to the given summary tree. */
     private addMetadataToSummary;
-    private addContainerStateToSummary;
+    protected addContainerStateToSummary(summaryTree: ISummaryTreeWithStats, fullTree: boolean, trackState: boolean, telemetryContext?: ITelemetryContext): void;
     private shouldContinueReconnecting;
     private resetReconnectCount;
     private replayPendingStates;
+    /**
+     * Parse an op's type and actual content from given serialized content
+     * ! Note: this format needs to be in-line with what is set in the "ContainerRuntime.submit(...)" method
+     */
+    private parseLocalOpContent;
     private applyStashedOp;
     setConnectionState(connected: boolean, clientId?: string): void;
+    private setConnectionStateCore;
+    notifyOpReplay(message: ISequencedDocumentMessage): Promise<void>;
     process(messageArg: ISequencedDocumentMessage, local: boolean): void;
-    private processAliasMessage;
+    private _processedClientSequenceNumber;
+    /**
+     * Direct the message to the correct subsystem for processing, and implement other side effects
+     */
+    private processCore;
+    /**
+     * Assuming the given message is also a TypedContainerRuntimeMessage,
+     * checks its type and dispatches the message to the appropriate handler in the runtime.
+     * Throws a DataProcessingError if the message looks like but doesn't conform to a known TypedContainerRuntimeMessage type.
+     */
+    private validateAndProcessRuntimeMessage;
     /**
      * Emits the Signal event and update the perf signal data.
      * @param clientSignalSequenceNumber - is the client signal sequence number to be uploaded.
      */
     private sendSignalTelemetryEvent;
     processSignal(message: ISignalMessage, local: boolean): void;
-    getRootDataStore(id: string, wait?: boolean): Promise<IFluidRouter>;
-    setFlushMode(mode: FlushMode): void;
-    flush(): void;
-    orderSequentially(callback: () => void): void;
-    private trackOrderSequentiallyCalls;
-    createDataStore(pkg: string | string[]): Promise<IDataStore>;
     /**
-     * Creates a root datastore directly with a user generated id and attaches it to storage.
-     * It is vulnerable to name collisions and should not be used.
-     *
-     * This method will be removed. See #6465.
+     * Flush the pending ops manually.
+     * This method is expected to be called at the end of a batch.
      */
-    private createRootDataStoreLegacy;
+    private flush;
+    orderSequentially<T>(callback: () => T): T;
     /**
-     * @deprecated - will be removed in an upcoming release. See #9660.
+     * Returns the aliased data store's entryPoint, given the alias.
+     * @param alias - The alias for the data store.
+     * @returns The data store's entry point ({@link @fluidframework/core-interfaces#IFluidHandle}) if it exists and is aliased.
+     * Returns undefined if no data store has been assigned the given alias.
      */
-    createRootDataStore(pkg: string | string[], rootDataStoreId: string): Promise<IFluidRouter>;
-    /**
-     * Creates a data store then attempts to alias it.
-     * If aliasing fails, it will raise an exception.
-     *
-     * This method will be removed. See #6465.
-     *
-     * @param pkg - Package name of the data store
-     * @param alias - Alias to be assigned to the data store
-     * @param props - Properties for the data store
-     * @returns - An aliased data store which can can be found / loaded by alias.
-     */
-    private createAndAliasDataStore;
+    getAliasedDataStoreEntryPoint(alias: string): Promise<IFluidHandle<FluidObject> | undefined>;
     createDetachedRootDataStore(pkg: Readonly<string[]>, rootDataStoreId: string): IFluidDataStoreContextDetached;
     createDetachedDataStore(pkg: Readonly<string[]>): IFluidDataStoreContextDetached;
+    createDataStore(pkg: string | string[]): Promise<IDataStore>;
     /**
-     * Creates a possibly root datastore directly with a possibly user generated id and attaches it to storage.
-     * It is vulnerable to name collisions if both aforementioned conditions are true, and should not be used.
-     *
-     * This method will be removed. See #6465.
+     * @deprecated 0.16 Issue #1537, #3631
      */
-    private _createDataStoreWithPropsLegacy;
-    _createDataStoreWithProps(pkg: string | string[], props?: any, id?: string, isRoot?: boolean): Promise<IDataStore>;
-    private _createDataStore;
+    _createDataStoreWithProps(pkg: string | string[], props?: any, id?: string): Promise<IDataStore>;
     private canSendOps;
+    /**
+     * Are we in the middle of batching ops together?
+     */
+    private currentlyBatching;
+    private readonly _quorum;
     getQuorum(): IQuorumClients;
+    private readonly _audience;
     getAudience(): IAudience;
     /**
      * Returns true of container is dirty, i.e. there are some pending local changes that
@@ -460,9 +614,16 @@ 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 targetClientId - When specified, the signal is only sent to the provided client id.
      */
-    submitSignal(type: string, content: any): void;
-    submitDataStoreSignal(address: string, type: string, content: any): void;
+    submitSignal(type: string, content: any, targetClientId?: string): void;
+    /**
+     * Submits the signal to be sent to other clients.
+     * @param type - Type of the signal.
+     * @param content - Content of the signal.
+     * @param targetClientId - When specified, the signal is only sent to the provided client id.
+     */
+    submitDataStoreSignal(address: string, type: string, content: any, targetClientId?: string): void;
     setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
     /**
      * Create a summary. Used when attaching or serializing a detached container.
@@ -473,7 +634,7 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * @param telemetryContext - summary data passed through the layers for telemetry purposes
      */
     createSummary(blobRedirectTable?: Map<string, string>, telemetryContext?: ITelemetryContext): ISummaryTree;
-    getAbsoluteUrl(relativeUrl: string): Promise<string | undefined>;
+    readonly getAbsoluteUrl: (relativeUrl: string) => Promise<string | undefined>;
     private summarizeInternal;
     /**
      * Returns a summary of the runtime at the current sequence number.
@@ -484,41 +645,58 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
         /** True to track the state for this summary in the SummarizerNodes; defaults to true */
         trackState?: boolean;
         /** Logger to use for correlated summary events */
-        summaryLogger?: ITelemetryLogger;
+        summaryLogger?: ITelemetryLoggerExt;
         /** True to run garbage collection before summarizing; defaults to true */
         runGC?: boolean;
         /** True to generate full GC data */
         fullGC?: boolean;
         /** True to run GC sweep phase after the mark phase */
         runSweep?: boolean;
-    }): Promise<IRootSummaryTreeWithStats>;
+    }): Promise<ISummaryTreeWithStats>;
     /**
-     * Implementation of IGarbageCollectionRuntime::updateStateBeforeGC.
      * Before GC runs, called by the garbage collector to update any pending GC state. This is mainly used to notify
      * the garbage collector of references detected since the last GC run. Most references are notified immediately
      * but there can be some for which async operation is required (such as detecting new root data stores).
+     * @see IGarbageCollectionRuntime.updateStateBeforeGC
      */
     updateStateBeforeGC(): Promise<void>;
+    private getGCDataInternal;
     /**
-     * Implementation of IGarbageCollectionRuntime::getGCData.
      * Generates and returns the GC data for this container.
      * @param fullGC - true to bypass optimizations and force full generation of GC data.
+     * @see IGarbageCollectionRuntime.getGCData
      */
     getGCData(fullGC?: boolean): Promise<IGarbageCollectionData>;
     /**
-     * Implementation of IGarbageCollectionRuntime::updateUsedRoutes.
      * After GC has run, called to notify this container's nodes of routes that are used in it.
      * @param usedRoutes - The routes that are used in all nodes in this Container.
-     * @param gcTimestamp - The time when GC was run that generated these used routes. If any node node becomes
-     * unreferenced as part of this GC run, this should be used to update the time when it happens.
+     * @see IGarbageCollectionRuntime.updateUsedRoutes
+     */
+    updateUsedRoutes(usedRoutes: readonly string[]): void;
+    /**
+     * This is called to update objects whose routes are unused.
+     * @param unusedRoutes - Data store and attachment blob routes that are unused in this Container.
+     */
+    updateUnusedRoutes(unusedRoutes: readonly string[]): void;
+    /**
+     * @deprecated Replaced by deleteSweepReadyNodes.
+     */
+    deleteUnusedNodes(unusedRoutes: readonly string[]): string[];
+    /**
+     * After GC has run and identified nodes that are sweep ready, this is called to delete the sweep ready nodes.
+     * @param sweepReadyRoutes - The routes of nodes that are sweep ready and should be deleted.
+     * @returns The routes of nodes that were deleted.
      */
-    updateUsedRoutes(usedRoutes: string[], gcTimestamp?: number): void;
+    deleteSweepReadyNodes(sweepReadyRoutes: readonly string[]): readonly string[];
     /**
-     * When running GC in test mode, this is called to delete objects whose routes are unused. This enables testing
-     * scenarios with accessing deleted content.
-     * @param unusedRoutes - The routes that are unused in all data stores in this Container.
+     * This is called to update objects that are tombstones.
+     *
+     * A Tombstoned object has been unreferenced long enough that GC knows it won't be referenced again.
+     * Tombstoned objects are eventually deleted by GC.
+     *
+     * @param tombstonedRoutes - Data store and attachment blob routes that are tombstones in this Container.
      */
-    deleteUnusedRoutes(unusedRoutes: string[]): void;
+    updateTombstonedRoutes(tombstonedRoutes: readonly string[]): void;
     /**
      * Returns a server generated referenced timestamp to be used to track unreferenced nodes by GC.
      */
@@ -537,18 +715,25 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * Returns whether a given path is for attachment blobs that are in the format - "/BlobManager.basePath/...".
      */
     private isBlobPath;
+    /**
+     * From a given list of routes, separate and return routes that belong to blob manager and data stores.
+     * @param routes - A list of routes that can belong to data stores or blob manager.
+     * @returns Two route lists - One that contains routes for blob manager and another one that contains routes
+     * for data stores.
+     */
+    private getDataStoreAndBlobManagerRoutes;
     /**
      * Runs garbage collection and updates the reference / used state of the nodes in the container.
-     * @returns the statistics of the garbage collection run.
+     * @returns the statistics of the garbage collection run; undefined if GC did not run.
      */
     collectGarbage(options: {
         /** Logger to use for logging GC events */
-        logger?: ITelemetryLogger;
+        logger?: ITelemetryLoggerExt;
         /** True to run GC sweep phase after the mark phase */
         runSweep?: boolean;
         /** True to generate full GC data */
         fullGC?: boolean;
-    }): Promise<IGCStats>;
+    }, telemetryContext?: ITelemetryContext): Promise<IGCStats | undefined>;
     /**
      * Called when a new outbound reference is added to another node. This is used by garbage collection to identify
      * all references added in the system.
@@ -565,51 +750,68 @@ export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntim
      * @param options - options controlling how the summary is generated or submitted
      */
     submitSummary(options: ISubmitSummaryOptions): Promise<SubmitSummaryResult>;
-    private processRemoteChunkedMessage;
-    private addChunk;
-    private clearPartialChunks;
+    /**
+     * This helper is called during summarization. If the container is dirty, it will return a failed summarize result
+     * (IBaseSummarizeResult) unless this is the final summarize attempt and SkipFailingIncorrectSummary option is set.
+     * @param logger - The logger to be used for sending telemetry.
+     * @param referenceSequenceNumber - The reference sequence number of the summary attempt.
+     * @param minimumSequenceNumber - The minimum sequence number of the summary attempt.
+     * @param finalAttempt - Whether this is the final summary attempt.
+     * @param beforeSummaryGeneration - Whether this is called before summary generation or after.
+     * @returns failed summarize result (IBaseSummarizeResult) if summary should be failed, undefined otherwise.
+     */
+    private shouldFailSummaryOnPendingOps;
+    private get pendingMessagesCount();
+    private hasPendingMessages;
     private updateDocumentDirtyState;
     submitDataStoreOp(id: string, contents: any, localOpMetadata?: unknown): void;
     submitDataStoreAliasOp(contents: any, localOpMetadata: unknown): void;
-    uploadBlob(blob: ArrayBufferLike): Promise<IFluidHandle<ArrayBufferLike>>;
+    uploadBlob(blob: ArrayBufferLike, signal?: AbortSignal): Promise<IFluidHandle<ArrayBufferLike>>;
+    private maybeSubmitIdAllocationOp;
     private submit;
-    private submitMaybeChunkedMessages;
-    private submitChunkedMessage;
-    private submitSystemMessage;
-    private submitRuntimeMessage;
+    private scheduleFlush;
+    private submitSummaryMessage;
     /**
      * Throw an error if the runtime is closed.  Methods that are expected to potentially
      * be called after dispose due to asynchrony should not call this.
      */
     private verifyNotClosed;
+    private verifyCanSubmitOps;
+    private reSubmitBatch;
+    private reSubmit;
     /**
      * Finds the right store and asks it to resubmit the message. This typically happens when we
      * reconnect and there are pending messages.
-     * @param content - The content of the original message.
+     * ! Note: successfully resubmitting an op that has been successfully sequenced is not possible due to checks in the ConnectionStateHandler (Loader layer)
+     * @param message - The original LocalContainerRuntimeMessage.
      * @param localOpMetadata - The local metadata associated with the original message.
      */
-    private reSubmit;
+    private reSubmitCore;
     private rollback;
     /** Implementation of ISummarizerInternalsProvider.refreshLatestSummaryAck */
-    refreshLatestSummaryAck(proposalHandle: string | undefined, ackHandle: string, summaryRefSeq: number, summaryLogger: ITelemetryLogger): Promise<void>;
+    refreshLatestSummaryAck(options: IRefreshSummaryAckOptions): Promise<void>;
     /**
-     * Fetches the latest snapshot from storage and uses it to refresh SummarizerNode's
-     * internal state as it should be considered the latest summary ack.
+     * Fetches the latest snapshot from storage to refresh the cache as a performance optimization and closes the
+     * summarizer to reload from new state.
      * @param summaryLogger - logger to use when fetching snapshot from storage
-     * @returns downloaded snapshot's reference sequence number
-     */
-    private refreshLatestSummaryAckFromServer;
-    private fetchSnapshotFromStorage;
-    notifyAttaching(snapshot: ISnapshotTreeWithBlobContents): void;
-    getSnapshotBlobs(): Promise<void>;
-    getPendingLocalState(): IPendingRuntimeState;
-    readonly summarizeOnDemand: ISummarizer["summarizeOnDemand"];
-    readonly enqueueSummarize: ISummarizer["enqueueSummarize"];
-    /**
-     * * Forms a function that will request a Summarizer.
-     * @param loaderRouter - the loader acting as an IFluidRouter
-     * */
-    private formRequestSummarizerFn;
-    private processSavedOps;
+     * @returns a generic summarization error
+     */
+    private prefetchLatestSummaryThenClose;
+    private closeStaleSummarizer;
+    /**
+     * Downloads the latest snapshot from storage.
+     * By default, it also closes the container after downloading the snapshot. However, this may be
+     * overridden via options.
+     */
+    private fetchLatestSnapshotFromStorage;
+    getPendingLocalState(props?: IGetPendingLocalStateProps): Promise<unknown>;
+    summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults;
+    enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult;
+    /**
+     * Forms a function that will create and retrieve a Summarizer.
+     */
+    private formCreateSummarizerFn;
+    private validateSummaryHeuristicConfiguration;
+    private get groupedBatchingEnabled();
 }
 //# sourceMappingURL=containerRuntime.d.ts.map