@fluidframework/container-runtime 2.31.0 → 2.32.0

package/src/opLifecycle/outbox.ts

@@ -3,7 +3,6 @@
  * Licensed under the MIT License.
  */
 
-import { ICriticalContainerError } from "@fluidframework/container-definitions";
 import { IBatchMessage } from "@fluidframework/container-definitions/internal";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert, Lazy } from "@fluidframework/core-utils/internal";
@@ -16,7 +15,6 @@ import {
 } from "@fluidframework/telemetry-utils/internal";
 
 import { ICompressionRuntimeOptions } from "../containerRuntime.js";
-import { OutboundContainerRuntimeMessage } from "../messageTypes.js";
 import { PendingMessageResubmitData, PendingStateManager } from "../pendingStateManager.js";
 
 import {
@@ -26,12 +24,17 @@ import {
 	sequenceNumbersMatch,
 	type BatchId,
 } from "./batchManager.js";
-import { BatchMessage, IBatch, IBatchCheckpoint } from "./definitions.js";
+import {
+	LocalBatchMessage,
+	IBatchCheckpoint,
+	type OutboundBatchMessage,
+	type OutboundSingletonBatch,
+	type LocalBatch,
+	type OutboundBatch,
+} from "./definitions.js";
 import { OpCompressor } from "./opCompressor.js";
 import { OpGroupingManager } from "./opGroupingManager.js";
 import { OpSplitter } from "./opSplitter.js";
-// eslint-disable-next-line unused-imports/no-unused-imports -- Used by "@link" comment annotation below
-import { ensureContentsDeserialized } from "./remoteMessageProcessor.js";
 
 export interface IOutboxConfig {
 	readonly compressionOptions: ICompressionRuntimeOptions;
@@ -53,7 +56,7 @@ export interface IOutboxParameters {
 	readonly submitBatchFn:
 		| ((batch: IBatchMessage[], referenceSequenceNumber?: number) => number)
 		| undefined;
-	readonly legacySendBatchFn: (batch: IBatch) => number;
+	readonly legacySendBatchFn: (batch: OutboundBatch) => number;
 	readonly config: IOutboxConfig;
 	readonly compressor: OpCompressor;
 	readonly splitter: OpSplitter;
@@ -62,15 +65,6 @@ export interface IOutboxParameters {
 	readonly getCurrentSequenceNumbers: () => BatchSequenceNumbers;
 	readonly reSubmit: (message: PendingMessageResubmitData) => void;
 	readonly opReentrancy: () => boolean;
-	readonly closeContainer: (error?: ICriticalContainerError) => void;
-}
-
-/**
- * Before submitting an op to the Outbox, its contents must be serialized using this function.
- * @remarks - The deserialization on process happens via the function {@link ensureContentsDeserialized}.
- */
-export function serializeOpContents(contents: OutboundContainerRuntimeMessage): string {
-	return JSON.stringify(contents);
 }
 
 /**
@@ -258,25 +252,28 @@ export class Outbox {
 		throw errorWrapper.value;
 	}
 
-	public submit(message: BatchMessage): void {
+	public submit(message: LocalBatchMessage): void {
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.mainBatch, message);
 	}
 
-	public submitBlobAttach(message: BatchMessage): void {
+	public submitBlobAttach(message: LocalBatchMessage): void {
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.blobAttachBatch, message);
 	}
 
-	public submitIdAllocation(message: BatchMessage): void {
+	public submitIdAllocation(message: LocalBatchMessage): void {
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.idAllocationBatch, message);
 	}
 
-	private addMessageToBatchManager(batchManager: BatchManager, message: BatchMessage): void {
+	private addMessageToBatchManager(
+		batchManager: BatchManager,
+		message: LocalBatchMessage,
+	): void {
 		if (
 			!batchManager.push(
 				message,
@@ -285,7 +282,7 @@ export class Outbox {
 			)
 		) {
 			throw new GenericError("BatchTooLarge", /* error */ undefined, {
-				opSize: message.contents?.length ?? 0,
+				opSize: message.serializedOp?.length ?? 0,
 				batchSize: batchManager.contentSizeInBytes,
 				count: batchManager.length,
 				limit: batchManager.options.hardLimit,
@@ -296,15 +293,16 @@ export class Outbox {
 	/**
 	 * Flush all the batches to the ordering service.
 	 * This method is expected to be called at the end of a batch.
+	 *
+	 * @throws If called from a reentrant context, or if the batch being flushed is too large.
 	 * @param resubmittingBatchId - If defined, indicates this is a resubmission of a batch
 	 * with the given Batch ID, which must be preserved
 	 */
 	public flush(resubmittingBatchId?: BatchId): void {
-		if (this.isContextReentrant()) {
-			const error = new UsageError("Flushing is not supported inside DDS event handlers");
-			this.params.closeContainer(error);
-			throw error;
-		}
+		assert(
+			!this.isContextReentrant(),
+			0xb7b /* Flushing must not happen while incoming changes are being processed */,
+		);
 
 		this.flushAll(resubmittingBatchId);
 	}
@@ -346,16 +344,19 @@ export class Outbox {
 			referenceSequenceNumber !== undefined,
 			0xa01 /* reference sequence number should be defined */,
 		);
-		const emptyGroupedBatch = this.params.groupingManager.createEmptyGroupedBatch(
-			resubmittingBatchId,
-			referenceSequenceNumber,
-		);
+		const { outboundBatch, placeholderMessage } =
+			this.params.groupingManager.createEmptyGroupedBatch(
+				resubmittingBatchId,
+				referenceSequenceNumber,
+			);
 		let clientSequenceNumber: number | undefined;
 		if (this.params.shouldSend()) {
-			clientSequenceNumber = this.sendBatch(emptyGroupedBatch);
+			clientSequenceNumber = this.sendBatch(outboundBatch);
 		}
+
+		// Push the empty batch placeholder to the PendingStateManager
 		this.params.pendingStateManager.onFlushBatch(
-			emptyGroupedBatch.messages, // This is the single empty Grouped Batch message
+			[{ ...placeholderMessage, serializedOp: "", contents: undefined }], // placeholder message - serializedOp will never be used
 			clientSequenceNumber,
 		);
 		return;
@@ -371,9 +372,16 @@ export class Outbox {
 		}
 
 		const rawBatch = batchManager.popBatch(resubmittingBatchId);
-		const shouldGroup =
-			!disableGroupedBatching && this.params.groupingManager.shouldGroup(rawBatch);
-		if (batchManager.options.canRebase && rawBatch.hasReentrantOps === true && shouldGroup) {
+		const groupingEnabled =
+			!disableGroupedBatching && this.params.groupingManager.groupedBatchingEnabled();
+		if (
+			batchManager.options.canRebase &&
+			rawBatch.hasReentrantOps === true &&
+			// NOTE: This is too restrictive. We should rebase for any reentrant op, not just if it's going to be a grouped batch
+			// However there is some test that is depending on this behavior so we haven't removed these conditions yet. See AB#33427
+			groupingEnabled &&
+			rawBatch.messages.length > 1
+		) {
 			assert(!this.rebasing, 0x6fa /* A rebased batch should never have reentrant ops */);
 			// If a batch contains reentrant ops (ops created as a result from processing another op)
 			// it needs to be rebased so that we can ensure consistent reference sequence numbers
@@ -387,12 +395,9 @@ export class Outbox {
 		// If so, do nothing, as pending state manager will resubmit it correctly on reconnect.
 		// Because flush() is a task that executes async (on clean stack), we can get here in disconnected state.
 		if (this.params.shouldSend()) {
-			const processedBatch = disableGroupedBatching
-				? rawBatch
-				: this.compressAndChunkBatch(
-						shouldGroup ? this.params.groupingManager.groupBatch(rawBatch) : rawBatch,
-					);
-			clientSequenceNumber = this.sendBatch(processedBatch);
+			const virtualizedBatch = this.virtualizeBatch(rawBatch, groupingEnabled);
+
+			clientSequenceNumber = this.sendBatch(virtualizedBatch);
 			assert(
 				clientSequenceNumber === undefined || clientSequenceNumber >= 0,
 				0x9d2 /* unexpected negative clientSequenceNumber (empty batch should yield undefined) */,
@@ -412,15 +417,14 @@ export class Outbox {
 	 *
 	 * @param rawBatch - the batch to be rebased
 	 */
-	private rebase(rawBatch: IBatch, batchManager: BatchManager): void {
+	private rebase(rawBatch: LocalBatch, batchManager: BatchManager): void {
 		assert(!this.rebasing, 0x6fb /* Reentrancy */);
 		assert(batchManager.options.canRebase, 0x9a7 /* BatchManager does not support rebase */);
 
 		this.rebasing = true;
 		for (const message of rawBatch.messages) {
 			this.params.reSubmit({
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				content: message.contents!,
+				content: message.serializedOp,
 				localOpMetadata: message.localOpMetadata,
 				opMetadata: message.metadata,
 			});
@@ -447,45 +451,76 @@ export class Outbox {
 	}
 
 	/**
-	 * As necessary and enabled, compresses and chunks the given batch.
+	 * As necessary and enabled, groups / compresses / chunks the given batch.
 	 *
 	 * @remarks - If chunking happens, a side effect here is that 1 or more chunks are queued immediately for sending in next JS turn.
 	 *
-	 * @param batch - Raw or Grouped batch to consider for compression/chunking
-	 * @returns Either (A) the original batch, (B) a compressed batch (same length as original)
-	 * or (C) a batch containing the last chunk.
+	 * @param localBatch - Local Batch to be virtualized - i.e. transformed into an Outbound Batch
+	 * @param groupingEnabled - If true, Grouped batching is enabled.
+	 * @returns One of the following:
+	 * - (A) The original batch (Based on what's enabled)
+	 * - (B) A grouped batch (it's a singleton batch)
+	 * - (C) A compressed singleton batch
+	 * - (D) A singleton batch containing the last chunk.
 	 */
-	private compressAndChunkBatch(batch: IBatch): IBatch {
+	private virtualizeBatch(localBatch: LocalBatch, groupingEnabled: boolean): OutboundBatch {
+		// Shallow copy the local batch, updating the messages to be outbound messages
+		const originalBatch: OutboundBatch = {
+			...localBatch,
+			messages: localBatch.messages.map<OutboundBatchMessage>(
+				({ serializedOp, ...message }) => ({
+					contents: serializedOp,
+					...message,
+				}),
+			),
+		};
+
+		const originalOrGroupedBatch = groupingEnabled
+			? this.params.groupingManager.groupBatch(originalBatch)
+			: originalBatch;
+
+		if (originalOrGroupedBatch.messages.length !== 1) {
+			// Compression requires a single message, so return early otherwise.
+			return originalOrGroupedBatch;
+		}
+
+		// Regardless of whether we grouped or not, we now have a batch with a single message.
+		// Now proceed to compress/chunk it if necessary.
+		const singletonBatch = originalOrGroupedBatch as OutboundSingletonBatch;
+
 		if (
-			batch.messages.length === 0 ||
 			this.params.config.compressionOptions === undefined ||
 			this.params.config.compressionOptions.minimumBatchSizeInBytes >
-				batch.contentSizeInBytes ||
-			this.params.submitBatchFn === undefined ||
-			!this.params.groupingManager.groupedBatchingEnabled()
+				singletonBatch.contentSizeInBytes ||
+			this.params.submitBatchFn === undefined
 		) {
-			// Nothing to do if the batch is empty or if compression is disabled or not supported, or if we don't need to compress
-			return batch;
+			// Nothing to do if compression is disabled, unnecessary or unsupported.
+			return singletonBatch;
 		}
 
-		const compressedBatch = this.params.compressor.compressBatch(batch);
+		const compressedBatch = this.params.compressor.compressBatch(singletonBatch);
 
 		if (this.params.splitter.isBatchChunkingEnabled) {
 			return compressedBatch.contentSizeInBytes <= this.params.splitter.chunkSizeInBytes
 				? compressedBatch
-				: this.params.splitter.splitFirstBatchMessage(compressedBatch);
+				: this.params.splitter.splitSingletonBatchMessage(compressedBatch);
 		}
 
 		if (compressedBatch.contentSizeInBytes >= this.params.config.maxBatchSizeInBytes) {
-			throw new GenericError("BatchTooLarge", /* error */ undefined, {
-				batchSize: batch.contentSizeInBytes,
-				compressedBatchSize: compressedBatch.contentSizeInBytes,
-				count: compressedBatch.messages.length,
-				limit: this.params.config.maxBatchSizeInBytes,
-				chunkingEnabled: this.params.splitter.isBatchChunkingEnabled,
-				compressionOptions: JSON.stringify(this.params.config.compressionOptions),
-				socketSize: estimateSocketSize(batch),
-			});
+			throw DataProcessingError.create(
+				"BatchTooLarge",
+				"compressionInsufficient",
+				/* sequencedMessage */ undefined,
+				{
+					batchSize: singletonBatch.contentSizeInBytes,
+					compressedBatchSize: compressedBatch.contentSizeInBytes,
+					count: compressedBatch.messages.length,
+					limit: this.params.config.maxBatchSizeInBytes,
+					chunkingEnabled: this.params.splitter.isBatchChunkingEnabled,
+					compressionOptions: JSON.stringify(this.params.config.compressionOptions),
+					socketSize: estimateSocketSize(singletonBatch),
+				},
+			);
 		}
 
 		return compressedBatch;
@@ -497,7 +532,7 @@ export class Outbox {
 	 * @param batch - batch to be sent
 	 * @returns the clientSequenceNumber of the start of the batch, or undefined if nothing was sent
 	 */
-	private sendBatch(batch: IBatch): number | undefined {
+	private sendBatch(batch: OutboundBatch): number | undefined {
 		const length = batch.messages.length;
 		if (length === 0) {
 			return undefined; // Nothing submitted

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -19,9 +19,6 @@ import { asBatchMetadata } from "../metadata.js";
 import { OpDecompressor } from "./opDecompressor.js";
 import { OpGroupingManager, isGroupedBatch } from "./opGroupingManager.js";
 import { OpSplitter, isChunkedMessage } from "./opSplitter.js";
-// eslint-disable-next-line unused-imports/no-unused-imports -- Used by "@link" comment annotation below
-import { serializeOpContents } from "./outbox.js";
-
 /**
  * Info about the batch we learn when we process the first message
  */
@@ -247,20 +244,6 @@ export class RemoteMessageProcessor {
 	}
 }
 
-/**
- * Takes an incoming runtime message JSON.parse's its contents in place, if needed (old Loader does this for us).
- * Only to be used for runtine messages.
- * @remarks - Serialization during submit happens via {@link serializeOpContents}
- * @param mutableMessage - op message received
- */
-export function ensureContentsDeserialized(mutableMessage: ISequencedDocumentMessage): void {
-	// This should become unconditional once Loader LTS reaches 2.4 or later.
-	// There will be a long time of needing both cases, until LTS advances to that point.
-	if (typeof mutableMessage.contents === "string" && mutableMessage.contents !== "") {
-		mutableMessage.contents = JSON.parse(mutableMessage.contents);
-	}
-}
-
 /**
  * For a given message, it moves the nested InboundContainerRuntimeMessage props one level up.
  *

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.31.0";
+export const pkgVersion = "2.32.0";

package/src/pendingStateManager.ts

@@ -23,7 +23,7 @@ import {
 import { asBatchMetadata, asEmptyBatchLocalOpMetadata } from "./metadata.js";
 import {
 	BatchId,
-	BatchMessage,
+	LocalBatchMessage,
 	getEffectiveBatchId,
 	BatchStartInfo,
 	InboundMessageResult,
@@ -305,7 +305,7 @@ export class PendingStateManager implements IDisposable {
 	 * @param ignoreBatchId - Whether to ignore the batchId in the batchStartInfo
 	 */
 	public onFlushBatch(
-		batch: BatchMessage[],
+		batch: LocalBatchMessage[],
 		clientSequenceNumber: number | undefined,
 		ignoreBatchId?: boolean,
 	): void {
@@ -325,7 +325,7 @@ export class PendingStateManager implements IDisposable {
 
 		for (const message of batch) {
 			const {
-				contents: content = "",
+				serializedOp: content,
 				referenceSequenceNumber,
 				localOpMetadata,
 				metadata: opMetadata,

package/src/runtimeLayerCompatState.ts

@@ -9,6 +9,7 @@ import {
 	type ILayerCompatSupportRequirements,
 } from "@fluid-internal/client-utils";
 import type { ICriticalContainerError } from "@fluidframework/container-definitions";
+import { encodeHandlesInContainerRuntime } from "@fluidframework/runtime-definitions/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import { pkgVersion } from "./packageVersion.js";
@@ -63,9 +64,9 @@ export const loaderSupportRequirements: ILayerCompatSupportRequirements = {
 export const runtimeCompatDetailsForDataStore: ILayerCompatDetails = {
 	...runtimeCoreCompatDetails,
 	/**
-	 * The features supported by the Runtime layer across the Runtime / Loader boundary.
+	 * The features supported by the Runtime layer across the Runtime / DataStore boundary.
 	 */
-	supportedFeatures: new Set<string>(),
+	supportedFeatures: new Set<string>([encodeHandlesInContainerRuntime]),
 };
 
 /**

package/src/summary/index.ts

@@ -3,31 +3,6 @@
  * Licensed under the MIT License.
  */
 
-export {
-	IOrderedClientCollection,
-	IOrderedClientElection,
-	ISerializedElection,
-	ITrackedClient,
-	OrderedClientCollection,
-	OrderedClientElection,
-} from "./orderedClientElection.js";
-export {
-	defaultMaxAttemptsForSubmitFailures,
-	RunningSummarizer,
-} from "./runningSummarizer.js";
-export {
-	ICancellableSummarizerController,
-	neverCancelledSummaryToken,
-	RunWhileConnectedCoordinator,
-} from "./runWhileConnectedCoordinator.js";
-export { Summarizer } from "./summarizer.js";
-export {
-	ISummarizerClientElection,
-	ISummarizerClientElectionEvents,
-	SummarizerClientElection,
-	summarizerClientType,
-} from "./summarizerClientElection.js";
-export { SummarizeHeuristicData, SummarizeHeuristicRunner } from "./summarizerHeuristics.js";
 export {
 	createRootSummarizerNode,
 	createRootSummarizerNodeWithGC,
@@ -36,6 +11,7 @@ export {
 	IRootSummarizerNodeWithGC,
 } from "./summarizerNode/index.js";
 export {
+	summarizerClientType,
 	IConnectableRuntime,
 	IGeneratedSummaryStats,
 	IRefreshSummaryAckOptions,
@@ -43,19 +19,14 @@ export {
 	ISummarizeAttempt,
 	ISummarizeHeuristicData,
 	ISummarizer,
-	ISummarizeResults,
 	ISummarizerInternalsProvider,
 	ISummarizerRuntime,
 	ISummaryCancellationToken,
 	SubmitSummaryResult,
-	EnqueueSummarizeResult,
-	IAckSummaryResult,
 	IBaseSummarizeResult,
-	IBroadcastSummaryResult,
 	ICancellationToken,
 	IEnqueueSummarizeOptions,
 	IGenerateSummaryTreeResult,
-	INackSummaryResult,
 	IOnDemandSummarizeOptions,
 	ISubmitSummaryOpResult,
 	ISummarizeOptions,
@@ -71,6 +42,14 @@ export {
 	type ISummaryConfigurationHeuristics,
 	type ISummaryBaseConfiguration,
 } from "./summarizerTypes.js";
+export {
+	IOrderedClientCollection,
+	IOrderedClientElection,
+	ISerializedElection,
+	ITrackedClient,
+	OrderedClientCollection,
+	OrderedClientElection,
+} from "./orderedClientElection.js";
 export {
 	IAckedSummary,
 	ISummaryCollectionOpEvents,
@@ -83,6 +62,11 @@ export {
 	OpActionEventListener,
 	OpActionEventName,
 } from "./summaryCollection.js";
+export {
+	ISummarizerClientElection,
+	ISummarizerClientElectionEvents,
+	SummarizerClientElection,
+} from "./summarizerClientElection.js";
 export {
 	aliasBlobName,
 	chunksBlobName,
@@ -125,7 +109,11 @@ export {
 	IDocumentSchemaChangeMessage,
 	IDocumentSchemaFeatures,
 } from "./documentSchema.js";
-export { getFailMessage, RetriableSummaryError, SummarizeReason } from "./summaryGenerator.js";
+export {
+	getFailMessage,
+	RetriableSummaryError,
+	SummarizeReason,
+} from "./summarizerUtils.js";
 export {
 	IConnectedEvents,
 	IConnectedState,
@@ -133,3 +121,19 @@ export {
 	SummaryManager,
 	SummaryManagerState,
 } from "./summaryManager.js";
+export {
+	defaultMaxAttempts,
+	defaultMaxAttemptsForSubmitFailures,
+	ICancellableSummarizerController,
+	neverCancelledSummaryToken,
+	RunWhileConnectedCoordinator,
+	Summarizer,
+	IBroadcastSummaryResult,
+	ISummarizeResults,
+	EnqueueSummarizeResult,
+	IAckSummaryResult,
+	INackSummaryResult,
+	RunningSummarizer,
+	SummarizeHeuristicData,
+	SummarizeHeuristicRunner,
+} from "./summaryDelayLoadedModule/index.js";

package/src/summary/orderedClientElection.ts

@@ -16,7 +16,7 @@ import {
 	createChildLogger,
 } from "@fluidframework/telemetry-utils/internal";
 
-import { summarizerClientType } from "./summarizerClientElection.js";
+import { summarizerClientType } from "./index.js";
 
 // helper types for recursive readonly.
 // eslint-disable-next-line @typescript-eslint/ban-types

package/src/summary/summarizerClientElection.ts

@@ -14,10 +14,9 @@ import {
 	ISerializedElection,
 	ITrackedClient,
 } from "./orderedClientElection.js";
+import { summarizerClientType } from "./summarizerTypes.js";
 import { ISummaryCollectionOpEvents } from "./summaryCollection.js";
 
-export const summarizerClientType = "summarizer";
-
 export interface ISummarizerClientElectionEvents extends IEvent {
 	(event: "electedSummarizerChanged", handler: () => void): void;
 }

package/src/summary/summarizerTypes.ts

@@ -27,12 +27,13 @@ import {
 	ITelemetryLoggerPropertyBag,
 } from "@fluidframework/telemetry-utils/internal";
 
-import {
-	ISummaryAckMessage,
-	ISummaryNackMessage,
-	ISummaryOpMessage,
-} from "./summaryCollection.js";
-import { SummarizeReason } from "./summaryGenerator.js";
+import type { SummarizeReason } from "./summarizerUtils.js";
+import type {
+	EnqueueSummarizeResult,
+	ISummarizeResults,
+} from "./summaryDelayLoadedModule/index.js";
+
+export const summarizerClientType = "summarizer";
 
 /**
  * Similar to AbortSignal, but using promise instead of events
@@ -359,33 +360,6 @@ export interface SubmitSummaryFailureData {
 	stage: SummaryStage;
 }
 
-/**
- * @legacy
- * @alpha
- */
-export interface IBroadcastSummaryResult {
-	readonly summarizeOp: ISummaryOpMessage;
-	readonly broadcastDuration: number;
-}
-
-/**
- * @legacy
- * @alpha
- */
-export interface IAckSummaryResult {
-	readonly summaryAckOp: ISummaryAckMessage;
-	readonly ackNackDuration: number;
-}
-
-/**
- * @legacy
- * @alpha
- */
-export interface INackSummaryResult {
-	readonly summaryNackOp: ISummaryNackMessage;
-	readonly ackNackDuration: number;
-}
-
 /**
  * @legacy
  * @alpha
@@ -402,64 +376,6 @@ export type SummarizeResultPart<TSuccess, TFailure = undefined> =
 			error: IRetriableFailureError;
 	  };
 
-/**
- * @legacy
- * @alpha
- */
-export interface ISummarizeResults {
-	/**
-	 * Resolves when we generate, upload, and submit the summary.
-	 */
-	readonly summarySubmitted: Promise<
-		SummarizeResultPart<SubmitSummaryResult, SubmitSummaryFailureData>
-	>;
-	/**
-	 * Resolves when we observe our summarize op broadcast.
-	 */
-	readonly summaryOpBroadcasted: Promise<SummarizeResultPart<IBroadcastSummaryResult>>;
-	/**
-	 * Resolves when we receive a summaryAck or summaryNack.
-	 */
-	readonly receivedSummaryAckOrNack: Promise<
-		SummarizeResultPart<IAckSummaryResult, INackSummaryResult>
-	>;
-}
-
-/**
- * @legacy
- * @alpha
- */
-export type EnqueueSummarizeResult =
-	| (ISummarizeResults & {
-			/**
-			 * Indicates that another summarize attempt is not already enqueued,
-			 * and this attempt has been enqueued.
-			 */
-			readonly alreadyEnqueued?: undefined;
-	  })
-	| (ISummarizeResults & {
-			/**
-			 * Indicates that another summarize attempt was already enqueued.
-			 */
-			readonly alreadyEnqueued: true;
-			/**
-			 * Indicates that the other enqueued summarize attempt was abandoned,
-			 * and this attempt has been enqueued enqueued.
-			 */
-			readonly overridden: true;
-	  })
-	| {
-			/**
-			 * Indicates that another summarize attempt was already enqueued.
-			 */
-			readonly alreadyEnqueued: true;
-			/**
-			 * Indicates that the other enqueued summarize attempt remains enqueued,
-			 * and this attempt has not been enqueued.
-			 */
-			readonly overridden?: undefined;
-	  };
-
 /**
  * @legacy
  * @alpha