@fluidframework/container-runtime 2.118.1 → 3.0.1

package/dist/containerRuntime.js

@@ -4,7 +4,12 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isContainerMessageDirtyable = exports.ContainerRuntime = exports.loadContainerRuntimeAlpha = exports.loadContainerRuntime = exports.getSingleUseLegacyLogCallback = exports.makeLegacySendBatchFn = exports.getDeviceSpec = exports.agentSchedulerId = exports.isUnpackedRuntimeMessage = exports.defaultPendingOpsRetryDelayMs = exports.defaultPendingOpsWaitTimeoutMs = exports.defaultRuntimeHeaderData = exports.InactiveResponseHeaderKey = exports.TombstoneResponseHeaderKey = exports.DeletedResponseHeaderKey = void 0;
+exports.ContainerRuntime = exports.getSingleUseLegacyLogCallback = exports.makeLegacySendBatchFn = exports.agentSchedulerId = exports.defaultPendingOpsRetryDelayMs = exports.defaultPendingOpsWaitTimeoutMs = exports.defaultRuntimeHeaderData = exports.InactiveResponseHeaderKey = exports.TombstoneResponseHeaderKey = exports.DeletedResponseHeaderKey = void 0;
+exports.isUnpackedRuntimeMessage = isUnpackedRuntimeMessage;
+exports.getDeviceSpec = getDeviceSpec;
+exports.loadContainerRuntime = loadContainerRuntime;
+exports.loadContainerRuntimeAlpha = loadContainerRuntimeAlpha;
+exports.isContainerMessageDirtyable = isContainerMessageDirtyable;
 const client_utils_1 = require("@fluid-internal/client-utils");
 const container_definitions_1 = require("@fluidframework/container-definitions");
 const internal_1 = require("@fluidframework/container-definitions/internal");
@@ -136,7 +141,6 @@ const defaultCloseSummarizerDelayMs = 5000; // 5 seconds
 function isUnpackedRuntimeMessage(message) {
     return Object.values(messageTypes_js_1.ContainerMessageType).includes(message.type);
 }
-exports.isUnpackedRuntimeMessage = isUnpackedRuntimeMessage;
 /**
  * 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
@@ -152,7 +156,6 @@ function getDeviceSpec() {
         hardwareConcurrency: navigator.hardwareConcurrency,
     };
 }
-exports.getDeviceSpec = getDeviceSpec;
 /**
  * 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,
@@ -211,7 +214,6 @@ async function loadContainerRuntime(params) {
         registry: new dataStoreRegistry_js_1.FluidDataStoreRegistry(params.registryEntries),
     });
 }
-exports.loadContainerRuntime = loadContainerRuntime;
 /**
  * Alpha variant of {@link loadContainerRuntime} that returns the runtime in an
  * extendable object, allowing additional properties to be added in the future.
@@ -231,7 +233,6 @@ async function loadContainerRuntimeAlpha(params) {
         registry: new dataStoreRegistry_js_1.FluidDataStoreRegistry(params.registryEntries),
     });
 }
-exports.loadContainerRuntimeAlpha = loadContainerRuntimeAlpha;
 const defaultMaxConsecutiveReconnects = 7;
 /**
  * These are the ONLY message types that are allowed to be submitted while in staging mode
@@ -254,6 +255,17 @@ function canStageMessageOfType(type) {
  * @internal
  */
 class ContainerRuntime extends client_utils_1.TypedEventEmitter {
+    registry;
+    metadata;
+    electedSummarizerData;
+    runtimeOptions;
+    containerScope;
+    _storage;
+    createIdCompressorFn;
+    documentsSchemaController;
+    minVersionForCollab;
+    requestHandler;
+    summaryConfiguration;
     /**
      * Load the stores from a snapshot and returns the runtime.
      * @param params - An object housing the runtime properties.
@@ -272,6 +284,11 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     static async loadRuntime(params) {
         return ContainerRuntime.loadRuntime2(params).then((r) => r.runtime);
     }
+    /**
+     * Hack to allow test-utils to detect which version of loadRuntime API to expect.
+     * See note in loadRuntime's private remarks.
+     */
+    static loadRuntimeAPIVersion = 2;
     /**
      * Load the stores from a snapshot and returns an object containing the runtime.
      * @remarks
@@ -310,8 +327,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         const mc = (0, internal_8.loggerToMonitoringContext)(logger);
         // Some options require a minimum version of the FF runtime to operate, so the default configs will be generated
         // based on the minVersionForCollab.
-        // For example, if minVersionForCollab is set to "1.0.0", the default configs will ensure compatibility with FF runtime
-        // 1.0.0 or later. If the minVersionForCollab is set to "2.10.0", the default values will be generated to ensure compatibility
+        // For example, if minVersionForCollab is set to "2.0.0", the default configs will ensure compatibility with FF runtime
+        // 2.0.0 or later. If the minVersionForCollab is set to "2.10.0", the default values will be generated to ensure compatibility
         // with FF runtime 2.10.0 or later.
         if (!(0, internal_7.isValidMinVersionForCollab)(minVersionForCollab)) {
             throw new internal_8.UsageError(`Invalid minVersionForCollab: ${minVersionForCollab}. It must be an existing FF version (i.e. 2.22.1).`);
@@ -522,15 +539,27 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         await runtime.pendingStateManager.applyStashedOpsAt(runtimeSequenceNumber ?? 0);
         return { runtime };
     }
+    options;
+    _getClientId;
     get clientId() {
         return this._getClientId();
     }
+    clientDetails;
+    isSummarizerClient;
     get storage() {
         return this._storage;
     }
     get containerRuntime() {
         return this;
     }
+    submitSummaryFn;
+    submitSignalFn;
+    disposeFn;
+    /**
+     * Initiate closing of the container due to a critical error.
+     * @param error - The critical error that caused the container to close.
+     */
+    closeFn;
     get flushMode() {
         return this._flushMode;
     }
@@ -540,9 +569,29 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     get IFluidDataStoreRegistry() {
         return this.registry;
     }
+    _getAttachState;
     get attachState() {
         return this._getAttachState();
     }
+    /**
+     * Whether local op submission is currently disallowed.
+     *
+     * This is `true` in two distinct situations.
+     *
+     * First: the delta manager reports a read-only connection (host/service-imposed permission or connection state — the historical meaning of `readOnly`).
+     *
+     * Second: the `PendingStateManager` is replaying stashed ops (`isApplyingStashedOps`). During this window DDSes must not submit new local ops, as doing so would interleave fresh content ahead of the stashed pending stream and corrupt pending local state. Surfacing it through `isReadOnly()` lets DDSes that consult `readOnly` at realize time self-suppress; see the apply-lifecycle docs on `PendingStateManager` for the full rationale.
+     *
+     * Note this layers a third meaning ("transiently quiescing for stashed-op replay") onto the `readOnly` predicate, which is broader than its host/connection-permission origin.
+     */
+    isReadOnly = () => 
+    // `_deltaManager` and `pendingStateManager` are both assigned partway
+    // through the constructor; `baseLogger` is built earlier and stamps
+    // `isReadOnly` on every error event (e.g. layer-compat failures
+    // during construction), so this can be called before either is
+    // assigned. Optional chains keep that window safe.
+    this._deltaManager?.readOnlyInfo.readonly === true ||
+        this.pendingStateManager?.isApplyingStashedOps === true;
     /**
      * Current session schema - defines what options are on & off.
      * It's overlap of document schema (controlled by summary & ops) and options controlling this session.
@@ -556,6 +605,15 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     get sessionSchema() {
         return this.documentsSchemaController.sessionSchema.runtime;
     }
+    _idCompressor;
+    // We accumulate Id compressor Ops while Id compressor is not loaded yet (only for "delayed" mode)
+    // Once it loads, it will process all such ops and we will stop accumulating further ops - ops will be processes as they come in.
+    pendingIdCompressorOps = [];
+    // Id Compressor serializes final state (see getPendingLocalState()). As result, it needs to skip all ops that preceeded that state
+    // (such ops will be marked by Loader layer as savedOp === true)
+    // That said, in "delayed" mode it's possible that Id Compressor was never initialized before getPendingLocalState() is called.
+    // In such case we have to process all ops, including those marked with savedOp === true.
+    skipSavedCompressorOps;
     /**
      * {@inheritDoc @fluidframework/runtime-definitions#IContainerRuntimeBase.idCompressor}
      */
@@ -578,6 +636,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     get IFluidHandleContext() {
         return this.handleContext;
     }
+    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
@@ -586,6 +645,41 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     get deltaManager() {
         return this._deltaManager;
     }
+    _deltaManager;
+    /**
+     * 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.
+     */
+    innerDeltaManager;
+    // internal logger for ContainerRuntime. Use this.logger for stores, summaries, etc.
+    mc;
+    summarizerClientElection;
+    /**
+     * summaryManager will only be created if this client is permitted to spawn a summarizing client
+     * It is created only by interactive client, i.e. summarizer client, as well as non-interactive bots
+     * do not create it (see SummarizerClientElection.clientDetailsPermitElection() for details)
+     */
+    summaryManager;
+    summarizerNode;
+    maxConsecutiveReconnects;
+    batchRunner = new runCounter_js_1.BatchRunCounter();
+    _flushMode;
+    stagingModeAutoFlushThreshold;
+    /**
+     * BatchId tracking is needed whenever there's a possibility of a "forked Container",
+     * where the same local state is pending in two different running Containers, each of
+     * which is trying to ensure it's persisted.
+     * "Offline Load" from serialized pending state is one such scenario since two Containers
+     * could load from the same serialized pending state.
+     */
+    batchIdTrackingEnabled;
+    flushScheduled = false;
+    canSendOps;
+    canSendSignals;
+    getConnectionState;
+    consecutiveReconnects = 0;
+    dataModelChangeRunner = new runCounter_js_1.RunCounter();
     /**
      * Invokes the given callback and expects that no ops are submitted
      * until execution finishes. If an op is submitted, it will be marked as reentrant.
@@ -608,15 +702,50 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     get summarizerClientId() {
         return this.summarizerClientElection?.electedClientId;
     }
+    _disposed = false;
     get disposed() {
         return this._disposed;
     }
+    lastEmittedDirty;
+    emitDirtyDocumentEvent = true;
+    lastEmittedHasStagedChanges;
+    useDeltaManagerOpsProxy;
+    closeSummarizerDelayMs;
+    signalTelemetryManager = new signalTelemetryProcessing_js_1.SignalTelemetryManager();
+    /**
+     * 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")
+     */
+    _summarizer;
+    deltaScheduler;
+    inboundBatchAggregator;
+    blobManager;
+    pendingStateManager;
+    duplicateBatchDetector;
+    versionMarkResolverInternal;
     /**
      * Host-facing version mark resolver.
      */
     get versionMarkResolver() {
         return this.versionMarkResolverInternal;
     }
+    outbox;
+    garbageCollector;
+    channelCollection;
+    remoteMessageProcessor;
+    versionMarkInboundBatchId;
+    /**
+     * The last message processed at the time of the last summary.
+     */
+    messageAtLastSummary;
+    summariesDisabled;
+    createContainerMetadata;
+    /**
+     * The summary number of the next summary that will be generated for this container. This is incremented every time
+     * a summary is generated.
+     */
+    nextSummaryNumber;
     /**
      * If false, loading or using a Tombstoned object should merely log, not fail.
      * @deprecated NOT SUPPORTED - hardcoded to return false since it's deprecated.
@@ -633,6 +762,27 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     get gcThrowOnTombstoneUsage() {
         return false;
     }
+    /**
+     * GUID to identify a document in telemetry
+     * ! Note: should not be used for anything other than telemetry and is not considered a stable GUID
+     */
+    telemetryDocumentId;
+    /**
+     * The id of the version used to initially load this runtime, or undefined if it's newly created.
+     */
+    loadedFromVersionId;
+    isSnapshotInstanceOfISnapshot;
+    /**
+     * The summary context of the last acked summary. The properties from this as used when uploading a summary.
+     */
+    lastAckedSummaryContext;
+    /**
+     * It a cache for holding mapping for loading groupIds with its snapshot from the service. Add expiry policy of 1 minute.
+     * Starting with 1 min and based on recorded usage we can tweak it later on.
+     */
+    snapshotCacheForLoadingGroupIds = new internal_2.PromiseCache({
+        expiry: { policy: "absolute", durationMs: 60000 },
+    });
     /**
      * The compatibility details of the Runtime layer that is exposed to the Loader layer
      * for validating Loader-Runtime compatibility.
@@ -640,6 +790,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     get ILayerCompatDetails() {
         return runtimeLayerCompatState_js_1.runtimeCompatDetailsForLoader;
     }
+    extensions = new Map();
+    baseLogger;
     /***/
     constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, 
     // Create a custom ITelemetryBaseLogger to output telemetry events.
@@ -663,206 +815,6 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         this.minVersionForCollab = minVersionForCollab;
         this.requestHandler = requestHandler;
         this.summaryConfiguration = summaryConfiguration;
-        /**
-         * Whether local op submission is currently disallowed.
-         *
-         * This is `true` in two distinct situations.
-         *
-         * First: the delta manager reports a read-only connection (host/service-imposed permission or connection state — the historical meaning of `readOnly`).
-         *
-         * Second: the `PendingStateManager` is replaying stashed ops (`isApplyingStashedOps`). During this window DDSes must not submit new local ops, as doing so would interleave fresh content ahead of the stashed pending stream and corrupt pending local state. Surfacing it through `isReadOnly()` lets DDSes that consult `readOnly` at realize time self-suppress; see the apply-lifecycle docs on `PendingStateManager` for the full rationale.
-         *
-         * Note this layers a third meaning ("transiently quiescing for stashed-op replay") onto the `readOnly` predicate, which is broader than its host/connection-permission origin.
-         */
-        this.isReadOnly = () => 
-        // `_deltaManager` and `pendingStateManager` are both assigned partway
-        // through the constructor; `baseLogger` is built earlier and stamps
-        // `isReadOnly` on every error event (e.g. layer-compat failures
-        // during construction), so this can be called before either is
-        // assigned. Optional chains keep that window safe.
-        this._deltaManager?.readOnlyInfo.readonly === true ||
-            this.pendingStateManager?.isApplyingStashedOps === true;
-        // We accumulate Id compressor Ops while Id compressor is not loaded yet (only for "delayed" mode)
-        // Once it loads, it will process all such ops and we will stop accumulating further ops - ops will be processes as they come in.
-        this.pendingIdCompressorOps = [];
-        this.batchRunner = new runCounter_js_1.BatchRunCounter();
-        this.flushScheduled = false;
-        this.consecutiveReconnects = 0;
-        this.dataModelChangeRunner = new runCounter_js_1.RunCounter();
-        this._disposed = false;
-        this.emitDirtyDocumentEvent = true;
-        this.signalTelemetryManager = new signalTelemetryProcessing_js_1.SignalTelemetryManager();
-        /**
-         * It a cache for holding mapping for loading groupIds with its snapshot from the service. Add expiry policy of 1 minute.
-         * Starting with 1 min and based on recorded usage we can tweak it later on.
-         */
-        this.snapshotCacheForLoadingGroupIds = new internal_2.PromiseCache({
-            expiry: { policy: "absolute", durationMs: 60000 },
-        });
-        this.extensions = new Map();
-        // Boolean payload from the `"readonly"` delta-manager event is intentionally
-        // ignored — `isReadOnly()` aggregates delta-manager readonly with the PSM
-        // apply window, and that aggregation is the source of truth for fanout.
-        // `channelCollection?.` guards against future wiring changes; both callers
-        // today (the `"readonly"` listener and `onAfterStashedOpsApplied`) fire
-        // after `channelCollection` is assigned.
-        this.notifyReadOnlyState = (_readonly) => this.channelCollection?.notifyReadOnlyState(this.isReadOnly());
-        /**
-         * Enter Staging Mode, such that ops submitted to the ContainerRuntime will not be sent to the ordering service.
-         * To exit Staging Mode, call either discardChanges or commitChanges on the Stage Controls returned from this method.
-         *
-         * @remarks
-         * The `stagingModeChanged` event is emitted when staging mode is entered or exited via this method.
-         * It is NOT emitted when staging mode is used internally (e.g. by `orderSequentially` for rollback support).
-         *
-         * @returns Controls for exiting Staging Mode.
-         */
-        this.enterStagingMode = () => this.enterStagingModeCore(false);
-        /**
-         * Internal implementation of enterStagingMode.
-         * @param silent - When true, suppresses `stagingModeChanged` event emission.
-         * Pass `true` when staging mode is used as an internal implementation detail (e.g. by
-         * `orderSequentially` for rollback support) so that external listeners only observe
-         * user-initiated staging mode transitions. Pass `false` for all public entry points.
-         */
-        this.enterStagingModeCore = (silent) => {
-            if (this.stageControls !== undefined) {
-                throw new internal_8.UsageError("Already in staging mode");
-            }
-            if (this.attachState === container_definitions_1.AttachState.Detached) {
-                throw new internal_8.UsageError("Cannot enter staging mode while Detached");
-            }
-            // Make sure Outbox is empty before entering staging mode,
-            // since we mark whole batches as "staged" or not to indicate whether to submit them.
-            this.flush();
-            // Note: `silent` is captured from the enclosing `enterStagingModeCore` call.
-            // When `true`, both enter and exit events are suppressed (see orderSequentially).
-            const exitStagingMode = (discardOrCommit, exitMethod) => {
-                if (this.stageControls !== stageControls) {
-                    throw new internal_8.UsageError("Not in staging mode");
-                }
-                try {
-                    internal_8.PerformanceEvent.timedExec(this.mc.logger, {
-                        eventName: `ExitStagingMode_${exitMethod}`,
-                    }, (event) => {
-                        // Final flush of any last staged changes
-                        // NOTE: We can't use this.flush() here, because orderSequentially uses StagingMode and in the rollback case we'll hit assert 0x24c
-                        this.outbox.flush();
-                        this.stageControls = undefined;
-                        const batchInfos = discardOrCommit();
-                        event.reportProgress({
-                            details: {
-                                autoFlushThreshold: this.stagingModeAutoFlushThreshold,
-                                batches: batchInfos.length,
-                                batchesAtOrOverThreshold: batchInfos.filter((b) => b.length >= this.stagingModeAutoFlushThreshold).length,
-                            },
-                        });
-                        this.channelCollection.notifyStagingMode(false);
-                    });
-                }
-                catch (error) {
-                    const normalizedError = (0, internal_8.normalizeError)(error);
-                    this.closeFn(normalizedError);
-                    throw normalizedError;
-                }
-                if (!silent) {
-                    this.emit("stagingModeChanged", {
-                        inStagingMode: false,
-                        commit: exitMethod === "commit",
-                    });
-                }
-            };
-            const stageControls = {
-                discardChanges: () => exitStagingMode(() => {
-                    // Pop all staged batches from the PSM and roll them back in LIFO order
-                    const batchInfos = this.pendingStateManager.popStagedBatches(({ runtimeOp, localOpMetadata }) => {
-                        this.rollbackStagedChange(runtimeOp, localOpMetadata);
-                    });
-                    this.updateDocumentDirtyState();
-                    this.updateHasStagedChangesState();
-                    return batchInfos;
-                }, "discard"),
-                commitChanges: (options) => {
-                    const { squash } = { ...defaultStagingCommitOptions, ...options };
-                    exitStagingMode(() => {
-                        // Replay all staged batches in typical FIFO order.
-                        // We'll be out of staging mode so they'll be sent to the service finally.
-                        const batchInfos = this.pendingStateManager.replayPendingStates({
-                            committingStagedBatches: true,
-                            squash,
-                        });
-                        this.updateHasStagedChangesState();
-                        return batchInfos;
-                    }, "commit");
-                },
-            };
-            this.stageControls = stageControls;
-            this.channelCollection.notifyStagingMode(true);
-            if (!silent) {
-                try {
-                    this.emit("stagingModeChanged", { inStagingMode: true });
-                }
-                catch (error) {
-                    // Don't let a listener error prevent the caller from receiving stage controls.
-                    this.mc.logger.sendErrorEvent({ eventName: "StagingModeChangedError" }, error);
-                }
-            }
-            return stageControls;
-        };
-        this.readAndParseBlob = async (id) => (0, internal_4.readAndParse)(this.storage, id);
-        /**
-         * ContainerRuntime knows about additional restrictions on when blob sharing can be resumed as compared
-         * to BlobManager. In particular, it wants to avoid sharing blobs while in readonly state, and it also
-         * wants to avoid sharing blobs before connection completes (otherwise it may cause the sharing to happen
-         * before processing shared ops).
-         *
-         * This method can be called safely before those conditions are met. In the background, it will wait until
-         * it is safe before initiating sharing. It will close the container on any error.
-         */
-        this.sharePendingBlobs = () => {
-            new Promise((resolve) => {
-                // eslint-disable-next-line unicorn/consistent-function-scoping
-                const canStartSharing = () => this.connected && this.deltaManager.readOnlyInfo.readonly !== true;
-                if (canStartSharing()) {
-                    resolve();
-                    return;
-                }
-                const checkCanShare = (readonly) => {
-                    if (canStartSharing()) {
-                        this.deltaManager.off("readonly", checkCanShare);
-                        this.off("connected", checkCanShare);
-                        resolve();
-                    }
-                };
-                this.deltaManager.on("readonly", checkCanShare);
-                this.on("connected", checkCanShare);
-            })
-                .then(this.blobManager.sharePendingBlobs)
-                // It may not be necessary to close the container on failures - this should just mean there's
-                // a handle in the container that is stuck pending, which is a scenario that customers need to
-                // handle anyway. Starting with this more aggressive/restrictive behavior to be cautious.
-                .catch(this.closeFn);
-        };
-        // While internal, ContainerRuntime has not been converted to use the new events support.
-        // Recreate the required events (new pattern) with injected, wrapper new emitter.
-        // It is lazily create to avoid listeners (old events) that ultimately go nowhere.
-        this.lazyEventsForExtensions = new internal_2.Lazy(() => {
-            const eventEmitter = (0, client_utils_1.createEmitter)();
-            if (this.getConnectionState) {
-                this.on("connectedToService", (clientId, canWrite) => {
-                    eventEmitter.emit("joined", { clientId, canWrite });
-                });
-                this.on("disconnectedFromService", () => eventEmitter.emit("disconnected"));
-                this.on("operabilityChanged", (canWrite) => eventEmitter.emit("operabilityChanged", canWrite));
-            }
-            else {
-                this.on("connected", (clientId) => {
-                    eventEmitter.emit("joined", { clientId, canWrite: true });
-                });
-                this.on("disconnected", () => eventEmitter.emit("disconnected"));
-            }
-            return eventEmitter;
-        });
         const { options, clientDetails, connected, baseSnapshot, submitFn, submitBatchFn, submitSummaryFn, submitSignalFn, disposeFn, closeFn, deltaManager, quorum, audience, signalAudience, pendingLocalState, snapshotWithContents, getConnectionState, } = context;
         this.getConnectionState = getConnectionState;
         // In old loaders without dispose functionality, closeFn is equivalent but will also switch container to readonly mode
@@ -1021,6 +973,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         const fetchOps = context.fetchOps;
         this.versionMarkResolverInternal = new index_js_4.VersionMarkResolver({
             getCurrentSequenceNumber: () => this.deltaManager.lastSequenceNumber,
+            getCurrentTimestamp: () => this.getCurrentReferenceTimestampMs(),
             getCurrentMinimumSequenceNumber: () => this.deltaManager.minimumSequenceNumber,
             getCurrentPendingBatchId: () => this.pendingStateManager.getMostRecentPendingBatchId(),
             logger: (0, internal_8.createChildLogger)({
@@ -1030,7 +983,8 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             // Seal the current outbound batch so a just-submitted edit gets a stable batchId in the pending
             // state before sealAndCaptureVersionMark reads it (a batchId is only assigned when flushed).
             flushPendingBatch: () => this.flush(),
-            // Wire the container-provided op reader (if any) so resolution can read historical ops.
+            // Keep this optional while a supported older loader may not provide fetchOps. AB#81034 tracks
+            // making it required once the Runtime -> Loader compatibility window reaches generation 21.
             getHistoricalOpReader: fetchOps ? () => ({ fetchMessages: fetchOps }) : undefined,
             // Unpack scanned historical ops through the same pipeline the live inbound path uses, so a
             // chunked batch's batchId (only restored after reassembly) is observed by the history scan too.
@@ -1038,15 +992,13 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 ? () => {
                     // A fresh processor per scan: it holds chunk-reassembly state, so it must not share
                     // the live inbound processor's state. submit/size args are unused on the read path.
-                    const scanProcessor = new index_js_3.RemoteMessageProcessor(new index_js_3.OpSplitter([], submitBatchFn, runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger), new index_js_3.OpDecompressor(this.mc.logger), new index_js_3.OpGroupingManager({ groupedBatchingEnabled: this.groupedBatchingEnabled }, this.mc.logger));
+                    const scanProcessor = new index_js_3.RemoteMessageProcessor(new index_js_3.OpSplitter([], submitBatchFn, runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger, { allowInitialPartialChunkStream: true }), new index_js_3.OpDecompressor(this.mc.logger), new index_js_3.OpGroupingManager({ groupedBatchingEnabled: this.groupedBatchingEnabled }, this.mc.logger));
                     return (op) => {
-                        // Mirror the live path: only modern runtime-envelope ops (type Operation, with a
-                        // client id) carry batches; skip system/server ops.
-                        if (op.type !== internal_3.MessageType.Operation || typeof op.clientId !== "string") {
+                        // Only runtime ops carry batches; deserialize a copy so the reader-owned op stays untouched.
+                        const messageCopy = (0, index_js_3.tryGetDeserializedRuntimeOpCopy)(op);
+                        if (messageCopy === undefined) {
                             return undefined;
                         }
-                        const messageCopy = { ...op };
-                        (0, index_js_3.ensureContentsDeserialized)(messageCopy);
                         return scanProcessor.process(messageCopy, (0, exports.getSingleUseLegacyLogCallback)(this.mc.logger, messageCopy.type));
                     };
                 }
@@ -1270,10 +1222,10 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
                 const clientId = this._getClientId();
                 return clientId === undefined
                     ? undefined
-                    : ({
+                    : {
                         clientId,
                         client: audience.getMember(clientId),
-                    });
+                    };
             };
             let oldClientId = this.clientId;
             this.on("connected", () => {
@@ -1685,6 +1637,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     async getEntryPoint() {
         return this.entryPoint;
     }
+    entryPoint;
     internalId(maybeAlias) {
         return this.channelCollection.internalId(maybeAlias);
     }
@@ -1903,6 +1856,13 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             (0, internal_2.assert)(this.pendingIdCompressorOps.length === 0, 0x976 /* No new ops added */);
         }
     }
+    // Boolean payload from the `"readonly"` delta-manager event is intentionally
+    // ignored — `isReadOnly()` aggregates delta-manager readonly with the PSM
+    // apply window, and that aggregation is the source of truth for fanout.
+    // `channelCollection?.` guards against future wiring changes; both callers
+    // today (the `"readonly"` listener and `onAfterStashedOpsApplied`) fire
+    // after `channelCollection` is assigned.
+    notifyReadOnlyState = (_readonly) => this.channelCollection?.notifyReadOnlyState(this.isReadOnly());
     setConnectionState(canSendOps, clientId) {
         this.setConnectionStateToConnectedOrDisconnected(canSendOps, clientId);
     }
@@ -2125,7 +2085,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             if (this.versionMarkResolverInternal.isTracking) {
                 const versionMarkUpdate = (0, index_js_4.inboundVersionMarkUpdate)(inboundResult, this.versionMarkInboundBatchId);
                 if (versionMarkUpdate.sequenced !== undefined) {
-                    this.versionMarkResolverInternal.processInboundBatch(versionMarkUpdate.sequenced.batchId, versionMarkUpdate.sequenced.sequenceNumber);
+                    this.versionMarkResolverInternal.processInboundBatch(versionMarkUpdate.sequenced.batchId, versionMarkUpdate.sequenced.sequenceNumber, versionMarkUpdate.sequenced.timestamp);
                 }
                 this.versionMarkInboundBatchId = versionMarkUpdate.carriedBatchId;
             }
@@ -2175,6 +2135,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             this.resetReconnectCount();
         }
     }
+    _processedClientSequenceNumber;
     /**
      * Processes inbound message(s). It calls delta scheduler according to the messages' location in the batch.
      * @param messagesWithMetadata - messages to process along with their metadata.
@@ -2511,6 +2472,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         }
         return result;
     }
+    stageControls;
     /**
      * If true, the ContainerRuntime is not submitting any new ops to the ordering service.
      * Ops submitted to the ContainerRuntime while in Staging Mode will be queued in the PendingStateManager,
@@ -2519,6 +2481,108 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     get inStagingMode() {
         return this.stageControls !== undefined;
     }
+    /**
+     * Enter Staging Mode, such that ops submitted to the ContainerRuntime will not be sent to the ordering service.
+     * To exit Staging Mode, call either discardChanges or commitChanges on the Stage Controls returned from this method.
+     *
+     * @remarks
+     * The `stagingModeChanged` event is emitted when staging mode is entered or exited via this method.
+     * It is NOT emitted when staging mode is used internally (e.g. by `orderSequentially` for rollback support).
+     *
+     * @returns Controls for exiting Staging Mode.
+     */
+    enterStagingMode = () => this.enterStagingModeCore(false);
+    /**
+     * Internal implementation of enterStagingMode.
+     * @param silent - When true, suppresses `stagingModeChanged` event emission.
+     * Pass `true` when staging mode is used as an internal implementation detail (e.g. by
+     * `orderSequentially` for rollback support) so that external listeners only observe
+     * user-initiated staging mode transitions. Pass `false` for all public entry points.
+     */
+    enterStagingModeCore = (silent) => {
+        if (this.stageControls !== undefined) {
+            throw new internal_8.UsageError("Already in staging mode");
+        }
+        if (this.attachState === container_definitions_1.AttachState.Detached) {
+            throw new internal_8.UsageError("Cannot enter staging mode while Detached");
+        }
+        // Make sure Outbox is empty before entering staging mode,
+        // since we mark whole batches as "staged" or not to indicate whether to submit them.
+        this.flush();
+        // Note: `silent` is captured from the enclosing `enterStagingModeCore` call.
+        // When `true`, both enter and exit events are suppressed (see orderSequentially).
+        const exitStagingMode = (discardOrCommit, exitMethod) => {
+            if (this.stageControls !== stageControls) {
+                throw new internal_8.UsageError("Not in staging mode");
+            }
+            try {
+                internal_8.PerformanceEvent.timedExec(this.mc.logger, {
+                    eventName: `ExitStagingMode_${exitMethod}`,
+                }, (event) => {
+                    // Final flush of any last staged changes
+                    // NOTE: We can't use this.flush() here, because orderSequentially uses StagingMode and in the rollback case we'll hit assert 0x24c
+                    this.outbox.flush();
+                    this.stageControls = undefined;
+                    const batchInfos = discardOrCommit();
+                    event.reportProgress({
+                        details: {
+                            autoFlushThreshold: this.stagingModeAutoFlushThreshold,
+                            batches: batchInfos.length,
+                            batchesAtOrOverThreshold: batchInfos.filter((b) => b.length >= this.stagingModeAutoFlushThreshold).length,
+                        },
+                    });
+                    this.channelCollection.notifyStagingMode(false);
+                });
+            }
+            catch (error) {
+                const normalizedError = (0, internal_8.normalizeError)(error);
+                this.closeFn(normalizedError);
+                throw normalizedError;
+            }
+            if (!silent) {
+                this.emit("stagingModeChanged", {
+                    inStagingMode: false,
+                    commit: exitMethod === "commit",
+                });
+            }
+        };
+        const stageControls = {
+            discardChanges: () => exitStagingMode(() => {
+                // Pop all staged batches from the PSM and roll them back in LIFO order
+                const batchInfos = this.pendingStateManager.popStagedBatches(({ runtimeOp, localOpMetadata }) => {
+                    this.rollbackStagedChange(runtimeOp, localOpMetadata);
+                });
+                this.updateDocumentDirtyState();
+                this.updateHasStagedChangesState();
+                return batchInfos;
+            }, "discard"),
+            commitChanges: (options) => {
+                const { squash } = { ...defaultStagingCommitOptions, ...options };
+                exitStagingMode(() => {
+                    // Replay all staged batches in typical FIFO order.
+                    // We'll be out of staging mode so they'll be sent to the service finally.
+                    const batchInfos = this.pendingStateManager.replayPendingStates({
+                        committingStagedBatches: true,
+                        squash,
+                    });
+                    this.updateHasStagedChangesState();
+                    return batchInfos;
+                }, "commit");
+            },
+        };
+        this.stageControls = stageControls;
+        this.channelCollection.notifyStagingMode(true);
+        if (!silent) {
+            try {
+                this.emit("stagingModeChanged", { inStagingMode: true });
+            }
+            catch (error) {
+                // Don't let a listener error prevent the caller from receiving stage controls.
+                this.mc.logger.sendErrorEvent({ eventName: "StagingModeChangedError" }, error);
+            }
+        }
+        return stageControls;
+    };
     /**
      * Returns the aliased data store's entryPoint, given the alias.
      * @param alias - The alias for the data store.
@@ -2565,12 +2629,21 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         // container runtime's ability to send ops depend on the actual readonly state of the delta manager.
         return this.connected && this.innerDeltaManager.readOnlyInfo.readonly !== true;
     }
+    _quorum;
     getQuorum() {
         return this._quorum;
     }
+    _audience;
     getAudience() {
         return this._audience;
     }
+    /**
+     * When defined, this {@link @fluidframework/container-definitions#IAudience}
+     * maintains member list using signals only.
+     * Thus "write" members may be known earlier than quorum and avoid noise from
+     * un-summarized quorum history.
+     */
+    signalAudience;
     /**
      * Returns true of container is dirty, i.e. there are some pending local changes that
      * either were not sent out to delta stream or were not yet acknowledged.
@@ -2670,6 +2743,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         this.addContainerStateToSummary(summarizeResult, true /* fullTree */, false /* trackState */, telemetryContext);
         return summarizeResult.summary;
     }
+    getAbsoluteUrl;
     /**
      * Builds the Summary tree including all the channels and the container state.
      *
@@ -3610,6 +3684,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             referenceSequenceNumber: summaryRefSeq,
         };
     }
+    readAndParseBlob = async (id) => (0, internal_4.readAndParse)(this.storage, id);
     /**
      * Fetches the latest snapshot from storage. If the fetched snapshot is same or newer than the one for which ack
      * was received, close this client. Fetching the snapshot will update the cache for this client so if it's
@@ -3701,6 +3776,39 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             return pendingRuntimeState;
         });
     }
+    /**
+     * ContainerRuntime knows about additional restrictions on when blob sharing can be resumed as compared
+     * to BlobManager. In particular, it wants to avoid sharing blobs while in readonly state, and it also
+     * wants to avoid sharing blobs before connection completes (otherwise it may cause the sharing to happen
+     * before processing shared ops).
+     *
+     * This method can be called safely before those conditions are met. In the background, it will wait until
+     * it is safe before initiating sharing. It will close the container on any error.
+     */
+    sharePendingBlobs = () => {
+        new Promise((resolve) => {
+            // eslint-disable-next-line unicorn/consistent-function-scoping
+            const canStartSharing = () => this.connected && this.deltaManager.readOnlyInfo.readonly !== true;
+            if (canStartSharing()) {
+                resolve();
+                return;
+            }
+            const checkCanShare = (readonly) => {
+                if (canStartSharing()) {
+                    this.deltaManager.off("readonly", checkCanShare);
+                    this.off("connected", checkCanShare);
+                    resolve();
+                }
+            };
+            this.deltaManager.on("readonly", checkCanShare);
+            this.on("connected", checkCanShare);
+        })
+            .then(this.blobManager.sharePendingBlobs)
+            // It may not be necessary to close the container on failures - this should just mean there's
+            // a handle in the container that is stuck pending, which is a scenario that customers need to
+            // handle anyway. Starting with this more aggressive/restrictive behavior to be cautious.
+            .catch(this.closeFn);
+    };
     summarizeOnDemand(options) {
         if (this._summarizer !== undefined) {
             return this._summarizer.summarizeOnDemand(options);
@@ -3729,6 +3837,26 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
             return this.summaryManager.enqueueSummarize(options);
         }
     }
+    // While internal, ContainerRuntime has not been converted to use the new events support.
+    // Recreate the required events (new pattern) with injected, wrapper new emitter.
+    // It is lazily create to avoid listeners (old events) that ultimately go nowhere.
+    lazyEventsForExtensions = new internal_2.Lazy(() => {
+        const eventEmitter = (0, client_utils_1.createEmitter)();
+        if (this.getConnectionState) {
+            this.on("connectedToService", (clientId, canWrite) => {
+                eventEmitter.emit("joined", { clientId, canWrite });
+            });
+            this.on("disconnectedFromService", () => eventEmitter.emit("disconnected"));
+            this.on("operabilityChanged", (canWrite) => eventEmitter.emit("operabilityChanged", canWrite));
+        }
+        else {
+            this.on("connected", (clientId) => {
+                eventEmitter.emit("joined", { clientId, canWrite: true });
+            });
+            this.on("disconnected", () => eventEmitter.emit("disconnected"));
+        }
+        return eventEmitter;
+    });
     getJoinedStatus() {
         const getConnectionState = this.getConnectionState;
         if (getConnectionState) {
@@ -3744,6 +3872,7 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
         }
         return "disconnected";
     }
+    submitExtensionSignal;
     acquireExtension(id, factory, ...useContext) {
         return this.acquireExtensionInternal(
         /* injectionPermitted */ true, id, factory, ...useContext);
@@ -3823,11 +3952,6 @@ class ContainerRuntime extends client_utils_1.TypedEventEmitter {
     }
 }
 exports.ContainerRuntime = ContainerRuntime;
-/**
- * Hack to allow test-utils to detect which version of loadRuntime API to expect.
- * See note in loadRuntime's private remarks.
- */
-ContainerRuntime.loadRuntimeAPIVersion = 2;
 function isContainerMessageDirtyable({ type, contents, }) {
     // Certain container runtime messages should not mark the container dirty such as the old built-in
     // AgentScheduler and Garbage collector messages.
@@ -3857,5 +3981,4 @@ function isContainerMessageDirtyable({ type, contents, }) {
     }
     return true;
 }
-exports.isContainerMessageDirtyable = isContainerMessageDirtyable;
 //# sourceMappingURL=containerRuntime.js.map