@fluidframework/container-runtime 2.118.1 → 3.0.1

package/lib/containerRuntime.js

@@ -32,7 +32,7 @@ import { DeltaScheduler } from "./deltaScheduler.js";
 import { GCNodeType, GarbageCollector, } from "./gc/index.js";
 import { InboundBatchAggregator } from "./inboundBatchAggregator.js";
 import { ContainerMessageType, } from "./messageTypes.js";
-import { DuplicateBatchDetector, ensureContentsDeserialized, largeBatchThreshold, OpCompressor, OpDecompressor, OpGroupingManager, OpSplitter, Outbox, RemoteMessageProcessor, } from "./opLifecycle/index.js";
+import { DuplicateBatchDetector, ensureContentsDeserialized, largeBatchThreshold, OpCompressor, OpDecompressor, OpGroupingManager, OpSplitter, Outbox, RemoteMessageProcessor, tryGetDeserializedRuntimeOpCopy, } from "./opLifecycle/index.js";
 import { pkgVersion } from "./packageVersion.js";
 import { PendingStateManager, } from "./pendingStateManager.js";
 import { BatchRunCounter, RunCounter } from "./runCounter.js";
@@ -247,6 +247,17 @@ function canStageMessageOfType(type) {
  * @internal
  */
 export class ContainerRuntime extends 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.
@@ -265,6 +276,11 @@ export class ContainerRuntime extends 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
@@ -303,8 +319,8 @@ export class ContainerRuntime extends TypedEventEmitter {
         const mc = 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 (!isValidMinVersionForCollab(minVersionForCollab)) {
             throw new UsageError(`Invalid minVersionForCollab: ${minVersionForCollab}. It must be an existing FF version (i.e. 2.22.1).`);
@@ -515,15 +531,27 @@ export class ContainerRuntime extends 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;
     }
@@ -533,9 +561,29 @@ export class ContainerRuntime extends 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.
@@ -549,6 +597,15 @@ export class ContainerRuntime extends 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}
      */
@@ -571,6 +628,7 @@ export class ContainerRuntime extends 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
@@ -579,6 +637,41 @@ export class ContainerRuntime extends 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 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();
     /**
      * 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.
@@ -601,15 +694,50 @@ export class ContainerRuntime extends TypedEventEmitter {
     get summarizerClientId() {
         return this.summarizerClientElection?.electedClientId;
     }
+    _disposed = false;
     get disposed() {
         return this._disposed;
     }
+    lastEmittedDirty;
+    emitDirtyDocumentEvent = true;
+    lastEmittedHasStagedChanges;
+    useDeltaManagerOpsProxy;
+    closeSummarizerDelayMs;
+    signalTelemetryManager = new 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.
@@ -626,6 +754,27 @@ export class ContainerRuntime extends 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 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.
@@ -633,6 +782,8 @@ export class ContainerRuntime extends TypedEventEmitter {
     get ILayerCompatDetails() {
         return runtimeCompatDetailsForLoader;
     }
+    extensions = new Map();
+    baseLogger;
     /***/
     constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, 
     // Create a custom ITelemetryBaseLogger to output telemetry events.
@@ -656,206 +807,6 @@ export class ContainerRuntime extends 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 BatchRunCounter();
-        this.flushScheduled = false;
-        this.consecutiveReconnects = 0;
-        this.dataModelChangeRunner = new RunCounter();
-        this._disposed = false;
-        this.emitDirtyDocumentEvent = true;
-        this.signalTelemetryManager = new 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 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 UsageError("Already in staging mode");
-            }
-            if (this.attachState === AttachState.Detached) {
-                throw new 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 UsageError("Not in staging mode");
-                }
-                try {
-                    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 = 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) => 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 Lazy(() => {
-            const eventEmitter = 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
@@ -1014,6 +965,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         const fetchOps = context.fetchOps;
         this.versionMarkResolverInternal = new VersionMarkResolver({
             getCurrentSequenceNumber: () => this.deltaManager.lastSequenceNumber,
+            getCurrentTimestamp: () => this.getCurrentReferenceTimestampMs(),
             getCurrentMinimumSequenceNumber: () => this.deltaManager.minimumSequenceNumber,
             getCurrentPendingBatchId: () => this.pendingStateManager.getMostRecentPendingBatchId(),
             logger: createChildLogger({
@@ -1023,7 +975,8 @@ export class ContainerRuntime extends 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.
@@ -1031,15 +984,13 @@ export class ContainerRuntime extends 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 RemoteMessageProcessor(new OpSplitter([], submitBatchFn, runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger), new OpDecompressor(this.mc.logger), new OpGroupingManager({ groupedBatchingEnabled: this.groupedBatchingEnabled }, this.mc.logger));
+                    const scanProcessor = new RemoteMessageProcessor(new OpSplitter([], submitBatchFn, runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger, { allowInitialPartialChunkStream: true }), new OpDecompressor(this.mc.logger), new 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 !== MessageType.Operation || typeof op.clientId !== "string") {
+                        // Only runtime ops carry batches; deserialize a copy so the reader-owned op stays untouched.
+                        const messageCopy = tryGetDeserializedRuntimeOpCopy(op);
+                        if (messageCopy === undefined) {
                             return undefined;
                         }
-                        const messageCopy = { ...op };
-                        ensureContentsDeserialized(messageCopy);
                         return scanProcessor.process(messageCopy, getSingleUseLegacyLogCallback(this.mc.logger, messageCopy.type));
                     };
                 }
@@ -1263,10 +1214,10 @@ export class ContainerRuntime extends TypedEventEmitter {
                 const clientId = this._getClientId();
                 return clientId === undefined
                     ? undefined
-                    : ({
+                    : {
                         clientId,
                         client: audience.getMember(clientId),
-                    });
+                    };
             };
             let oldClientId = this.clientId;
             this.on("connected", () => {
@@ -1678,6 +1629,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     async getEntryPoint() {
         return this.entryPoint;
     }
+    entryPoint;
     internalId(maybeAlias) {
         return this.channelCollection.internalId(maybeAlias);
     }
@@ -1896,6 +1848,13 @@ export class ContainerRuntime extends TypedEventEmitter {
             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);
     }
@@ -2118,7 +2077,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             if (this.versionMarkResolverInternal.isTracking) {
                 const versionMarkUpdate = 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;
             }
@@ -2168,6 +2127,7 @@ export class ContainerRuntime extends 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.
@@ -2504,6 +2464,7 @@ export class ContainerRuntime extends 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,
@@ -2512,6 +2473,108 @@ export class ContainerRuntime extends 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 UsageError("Already in staging mode");
+        }
+        if (this.attachState === AttachState.Detached) {
+            throw new 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 UsageError("Not in staging mode");
+            }
+            try {
+                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 = 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.
@@ -2558,12 +2621,21 @@ export class ContainerRuntime extends 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.
@@ -2663,6 +2735,7 @@ export class ContainerRuntime extends 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.
      *
@@ -3603,6 +3676,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             referenceSequenceNumber: summaryRefSeq,
         };
     }
+    readAndParseBlob = async (id) => 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
@@ -3694,6 +3768,39 @@ export class ContainerRuntime extends 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);
@@ -3722,6 +3829,26 @@ export class ContainerRuntime extends 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 Lazy(() => {
+        const eventEmitter = 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) {
@@ -3737,6 +3864,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         return "disconnected";
     }
+    submitExtensionSignal;
     acquireExtension(id, factory, ...useContext) {
         return this.acquireExtensionInternal(
         /* injectionPermitted */ true, id, factory, ...useContext);
@@ -3815,11 +3943,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         return this.sessionSchema.opGroupingEnabled === true;
     }
 }
-/**
- * Hack to allow test-utils to detect which version of loadRuntime API to expect.
- * See note in loadRuntime's private remarks.
- */
-ContainerRuntime.loadRuntimeAPIVersion = 2;
 export 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.