@fluidframework/container-runtime 2.43.0-343119 → 2.50.0-345060

package/lib/containerRuntime.js

@@ -448,11 +448,11 @@ export class ContainerRuntime extends TypedEventEmitter {
                 runtime.setConnectionStateCore(true, runtime.delayConnectClientId);
             }
         }, (error) => runtime.closeFn(error));
+        // Initialize the base state of the runtime before it's returned.
+        await runtime.initializeBaseState(context.loader);
         // Apply stashed ops with a reference sequence number equal to the sequence number of the snapshot,
         // or zero. This must be done before Container replays saved ops.
         await runtime.pendingStateManager.applyStashedOpsAt(runtimeSequenceNumber ?? 0);
-        // Initialize the base state of the runtime before it's returned.
-        await runtime.initializeBaseState(context.loader);
         return runtime;
     }
     get clientId() {
@@ -621,15 +621,15 @@ export class ContainerRuntime extends TypedEventEmitter {
         // eslint-disable-next-line import/no-deprecated
         this.enterStagingMode = () => {
             if (this.stageControls !== undefined) {
-                throw new UsageError("already in staging mode");
+                throw new UsageError("Already in staging mode");
             }
             if (this.attachState === AttachState.Detached) {
-                throw new UsageError("cannot enter staging mode while 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();
-            const exitStagingMode = (discardOrCommit) => () => {
+            const exitStagingMode = (discardOrCommit) => {
                 try {
                     // 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
@@ -649,22 +649,23 @@ export class ContainerRuntime extends TypedEventEmitter {
             };
             // eslint-disable-next-line import/no-deprecated
             const stageControls = {
-                discardChanges: exitStagingMode(() => {
+                discardChanges: () => exitStagingMode(() => {
                     // Pop all staged batches from the PSM and roll them back in LIFO order
                     this.pendingStateManager.popStagedBatches(({ runtimeOp, localOpMetadata }) => {
-                        assert(runtimeOp !== undefined, 0xb82 /* Staged batches expected to have runtimeOp defined */);
-                        this.rollbackStagedChanges(runtimeOp, localOpMetadata);
+                        this.rollbackStagedChange(runtimeOp, localOpMetadata);
                     });
                     this.updateDocumentDirtyState();
                 }),
-                commitChanges: (optionsParam) => {
-                    const options = { ...defaultStagingCommitOptions, ...optionsParam };
-                    return exitStagingMode(() => {
+                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.
                         this.pendingStateManager.replayPendingStates({
-                            onlyStagedBatches: true,
-                            squash: options.squash ?? false,
+                            committingStagedBatches: true,
+                            squash,
                         });
-                    })();
+                    });
                 },
             };
             this.stageControls = stageControls;
@@ -1109,7 +1110,6 @@ export class ContainerRuntime extends TypedEventEmitter {
      * Initializes the state from the base snapshot this container runtime loaded from.
      */
     async initializeBaseState(loader) {
-        await this.initializeSummarizer(loader);
         if (this.sessionSchema.idCompressorMode === "on" ||
             (this.sessionSchema.idCompressorMode === "delayed" && this.connected)) {
             PerformanceEvent.timedExec(this.mc.logger, { eventName: "CreateIdCompressorOnBoot" }, (event) => {
@@ -1123,6 +1123,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             // This is called from loadRuntime(), long before we process any ops, so there should be no ops accumulated yet.
             assert(this.pendingIdCompressorOps.length === 0, 0x8ec /* no pending ops */);
         }
+        await this.initializeSummarizer(loader);
         await this.garbageCollector.initializeBaseState();
     }
     async initializeSummarizer(loader) {
@@ -2076,7 +2077,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                     try {
                         checkpoint.rollback((message) => 
                         // These changes are staged since we entered staging mode above
-                        this.rollbackStagedChanges(message.runtimeOp, message.localOpMetadata));
+                        this.rollbackStagedChange(message.runtimeOp, message.localOpMetadata));
                         this.updateDocumentDirtyState();
                         stageControls?.discardChanges();
                         stageControls = undefined;
@@ -3055,7 +3056,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     /**
      * Rollback the given op which was only staged but not yet submitted.
      */
-    rollbackStagedChanges({ type, contents }, localOpMetadata) {
+    rollbackStagedChange({ type, contents }, localOpMetadata) {
         assert(canStageMessageOfType(type), 0xbbc /* Unexpected message type to be rolled back */);
         switch (type) {
             case ContainerMessageType.FluidDataStoreOp: {