@fluidframework/container-runtime 2.110.0 → 2.112.0

package/lib/containerRuntime.js

@@ -747,6 +747,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                         this.rollbackStagedChange(runtimeOp, localOpMetadata);
                     });
                     this.updateDocumentDirtyState();
+                    this.updateHasStagedChangesState();
                     return batchInfos;
                 }, "discard"),
                 commitChanges: (options) => {
@@ -754,10 +755,12 @@ export class ContainerRuntime extends TypedEventEmitter {
                     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.
-                        return this.pendingStateManager.replayPendingStates({
+                        const batchInfos = this.pendingStateManager.replayPendingStates({
                             committingStagedBatches: true,
                             squash,
                         });
+                        this.updateHasStagedChangesState();
+                        return batchInfos;
                     }, "commit");
                 },
             };
@@ -1219,6 +1222,8 @@ export class ContainerRuntime extends TypedEventEmitter {
         // We haven't emitted dirty/saved yet, but this is the baseline so we know to emit when it changes
         this.lastEmittedDirty = this.computeCurrentDirtyState();
         context.updateDirtyContainerState(this.lastEmittedDirty);
+        // We haven't emitted hasStagedChangesChanged yet, but this is the baseline so we know to emit when it changes
+        this.lastEmittedHasStagedChanges = this.computeCurrentHasStagedChanges();
         // Reference Sequence Number may have just changed, and it must be consistent across a batch,
         // so we should flush now to clear the way for the next ops.
         // NOTE: This will be redundant whenever CR.process was called for the op (since we flush there too) -
@@ -1340,8 +1345,18 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (this.isSummarizerClient) {
             // We want to dynamically import any thing inside summaryDelayLoadedModule module only when we are the summarizer client,
             // so that all non summarizer clients don't have to load the code inside this module.
+            // Import the delay-loaded module by its leaf path rather than through the `./summary/index.js` barrel,
+            // which is also statically imported above for summarization dependencies every client loads
+            // (SummaryManager, SummaryCollection, SummarizerClientElection, etc.). A bundler that traces re-exports
+            // per symbol (e.g. webpack honoring sideEffects + providedExports) already keeps the summarizer out of
+            // the initial chunk even if this dynamic import targets the barrel, because the barrel's static importers
+            // use only non-summarizer symbols. A bundler without that analysis would instead treat the
+            // statically-imported barrel as making the whole summarizer subgraph available and fold it into the
+            // initial chunk. Targeting summaryDelayLoadedModule/index.js directly makes the split deterministic
+            // across bundlers.
             const module = await import(
-            /* webpackChunkName: "summarizerDelayLoadedModule" */ "./summary/index.js");
+            // eslint-disable-next-line import-x/no-internal-modules -- Needed to import the delay-loaded module directly.
+            /* webpackChunkName: "summarizerDelayLoadedModule" */ "./summary/summaryDelayLoadedModule/index.js");
             this._summarizer = new module.Summarizer(this /* ISummarizerRuntime */, () => this.summaryConfiguration, this /* ISummarizerInternalsProvider */, this.handleContext, summaryCollection, async (runtime) => module.RunWhileConnectedCoordinator.create(runtime, 
             // Summarization runs in summarizer client and needs access to the real (non-proxy) active
             // information. The proxy delta manager would always return false for summarizer client.
@@ -1992,11 +2007,13 @@ export class ContainerRuntime extends TypedEventEmitter {
                 const result = this.duplicateBatchDetector?.processInboundBatch(batchStart);
                 if (result?.duplicate === true) {
                     const error = new DataCorruptionError("Duplicate batch - The same batch was sequenced twice", { batchId: batchStart.batchId });
+                    const batchIdExplicit = batchStart.batchId !== undefined;
+                    const otherBatchIdExplicit = result.otherBatchInfo?.batchIdExplicit ?? false;
                     this.mc.logger.sendTelemetryEvent({
                         eventName: "DuplicateBatch",
                         details: {
                             batchId: batchStart.batchId,
-                            batchIdExplicit: batchStart.batchId !== undefined,
+                            batchIdExplicit,
                             clientId: batchStart.clientId,
                             batchStartCsn: batchStart.batchStartCsn,
                             size: inboundResult.length,
@@ -2007,7 +2024,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                             // loaded from a summary snapshot rather than seen at runtime.
                             otherClientId: result.otherBatchInfo?.clientId,
                             otherBatchStartCsn: result.otherBatchInfo?.batchStartCsn,
-                            otherBatchIdExplicit: result.otherBatchInfo?.batchIdExplicit,
+                            otherBatchIdExplicit,
                             otherFromSnapshot: result.otherBatchInfo === undefined,
                             ...extractSafePropertiesFromMessage(batchStart.keyMessage),
                             // For grouped batches, `keyMessage` is one of the sub-messages produced by
@@ -2018,10 +2035,12 @@ export class ContainerRuntime extends TypedEventEmitter {
                             messageClientSequenceNumber: batchStart.batchStartCsn,
                         },
                     }, error);
-                    // Due to a live incident where we had a bug in the service that caused duplicate batches to be sent to clients, we want to log when we detect a duplicate batch, but we don't want to throw an error
-                    // as it could hit the same service bug. We need to monitor below event to catch legitimate container forking scenarios and reenable throwing the data corruption error once the service bug is fixed and we stop seeing duplicate batches in the wild
-                    // or once we are able to identify batch duplication reason (forking vs service bug).
-                    // throw error;
+                    // Only throw the error if either the current batch or the other batch has an explicit batchId since that indicates a meaningful duplication scenario
+                    // coming from our batch readings rather than a server outage scenario.
+                    const shouldThrowOnDuplicate = batchIdExplicit || otherBatchIdExplicit;
+                    if (shouldThrowOnDuplicate) {
+                        throw error;
+                    }
                 }
             }
             // Reach out to PendingStateManager, either to zip localOpMetadata into the *local* message list,
@@ -2340,6 +2359,11 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.closeFn(error2);
             throw error2;
         }
+        // Flushing moves any staged batch from the Outbox into the PendingStateManager. Since
+        // computeCurrentHasStagedChanges() now also considers a non-empty Outbox in Staging Mode, the
+        // externally-visible value shouldn't change here, but re-checking is cheap and keeps this
+        // method robust to future changes in how the two are tracked.
+        this.updateHasStagedChangesState();
     }
     /**
      * {@inheritDoc @fluidframework/runtime-definitions#IContainerRuntimeBase.orderSequentially}
@@ -2482,6 +2506,34 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.pendingStateManager.hasPendingUserChanges() ||
             this.outbox.containsUserChanges());
     }
+    /**
+     * Returns true if there are any staged changes, i.e. changes submitted while in Staging Mode
+     * (see {@link @fluidframework/runtime-definitions#IContainerRuntimeBaseInternal.enterStagingMode})
+     * that have not yet been discarded or committed.
+     *
+     * @remarks This is distinct from {@link ContainerRuntime.isDirty}: a container may be dirty due to
+     * ordinary unacknowledged local changes without having any staged changes.
+     */
+    get hasStagedChanges() {
+        // Rather than recomputing this in the moment, just regurgitate the last emitted state.
+        return this.lastEmittedHasStagedChanges;
+    }
+    /**
+     * Returns true if there are currently any staged (not yet discarded or committed) changes pending.
+     *
+     * @remarks While in Staging Mode, newly submitted ops sit in the Outbox until the next flush before
+     * they're moved to the PendingStateManager (where `pendingStateManager.hasStagedChanges()` looks).
+     * So we also check the Outbox here, otherwise there would be a window between submit and flush where
+     * staged changes exist but this would incorrectly report false.
+     *
+     * @remarks We don't care about the type of ops in the Outbox here (unlike dirty state), just whether
+     * there's anything queued at all, for consistency with how `pendingStateManager.hasStagedChanges()`
+     * doesn't discriminate by op type either.
+     */
+    computeCurrentHasStagedChanges() {
+        return (this.pendingStateManager.hasStagedChanges() ||
+            (this.inStagingMode && !this.outbox.isEmpty));
+    }
     /**
      * Submits the signal to be sent to other clients.
      * @param type - Type of the signal.
@@ -3086,12 +3138,28 @@ export class ContainerRuntime extends TypedEventEmitter {
      */
     updateDocumentDirtyState() {
         const dirty = this.computeCurrentDirtyState();
-        if (this.lastEmittedDirty === dirty) {
+        if (this.lastEmittedDirty !== dirty) {
+            this.lastEmittedDirty = dirty;
+            if (this.emitDirtyDocumentEvent) {
+                this.emit(dirty ? "dirty" : "saved");
+            }
+        }
+    }
+    /**
+     * Emit "hasStagedChangesChanged" if the current staged-changes state differs from what was last emitted.
+     * This must be called explicitly at each place staged changes can be added or removed (submit, flush,
+     * discardChanges, commitChanges) -- unlike {@link ContainerRuntime.updateDocumentDirtyState}, it is not
+     * safe to call this unconditionally alongside dirty tracking, since most dirty-state transitions (e.g.
+     * acking ops, reconnecting) can't affect staged changes.
+     */
+    updateHasStagedChangesState() {
+        const hasStagedChanges = this.computeCurrentHasStagedChanges();
+        if (this.lastEmittedHasStagedChanges === hasStagedChanges) {
             return;
         }
-        this.lastEmittedDirty = dirty;
+        this.lastEmittedHasStagedChanges = hasStagedChanges;
         if (this.emitDirtyDocumentEvent) {
-            this.emit(dirty ? "dirty" : "saved");
+            this.emit("hasStagedChangesChanged", hasStagedChanges);
         }
     }
     // Keep in sync with IFluidRootParentContextPrivate.submitMessage.
@@ -3226,6 +3294,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             throw dpe;
         }
         this.updateDocumentDirtyState();
+        this.updateHasStagedChangesState();
     }
     scheduleFlush() {
         // During staging mode, suppress automatic flush scheduling until the main batch