@fluidframework/container-runtime 2.32.0 → 2.33.0

package/src/dataStoreContext.ts

@@ -5,11 +5,17 @@
 
 import { TypedEventEmitter, type ILayerCompatDetails } from "@fluid-internal/client-utils";
 import { AttachState, IAudience } from "@fluidframework/container-definitions";
-import { IDeltaManager } from "@fluidframework/container-definitions/internal";
+import {
+	IDeltaManager,
+	isIDeltaManagerFull,
+	type IDeltaManagerFull,
+	type ReadOnlyInfo,
+} from "@fluidframework/container-definitions/internal";
 import {
 	FluidObject,
 	IDisposable,
 	ITelemetryBaseProperties,
+	type IErrorBase,
 	type IEvent,
 } from "@fluidframework/core-interfaces";
 import {
@@ -75,6 +81,7 @@ import {
 	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils/internal";
 
+import { BaseDeltaManagerProxy } from "./deltaManagerProxies.js";
 import {
 	runtimeCompatDetailsForDataStore,
 	validateDatastoreCompatibility,
@@ -188,6 +195,58 @@ export interface IFluidDataStoreContextEvents extends IEvent {
 	(event: "attaching" | "attached", listener: () => void);
 }
 
+/**
+ * Eventually we should remove the delta manger from being exposed to Datastore runtimes via the context. However to remove that exposure we need to add new
+ * features, and those features themselves need forward and back compat. This proxy is here to enable that back compat. Each feature this proxy is used to
+ * support should be listed below, and as layer compat support goes away for those feature, we should also remove them from this proxy, with the eventual goal
+ * of completely removing this proxy.
+ *
+ * - Everything regarding readonly is to support older datastore runtimes which do not have the setReadonly function, so they must get their readonly state via the delta manager.
+ *
+ */
+class ContextDeltaManagerProxy extends BaseDeltaManagerProxy {
+	constructor(
+		base: IDeltaManagerFull,
+		private readonly isReadOnly: () => boolean,
+	) {
+		super(base, {
+			onReadonly: (): void => {
+				/* readonly is controlled from the context which calls setReadonly */
+			},
+		});
+	}
+
+	public get readOnlyInfo(): ReadOnlyInfo {
+		const readonly = this.isReadOnly();
+		if (readonly === this.deltaManager.readOnlyInfo.readonly) {
+			return this.deltaManager.readOnlyInfo;
+		} else {
+			return readonly === true
+				? {
+						readonly,
+						forced: false,
+						permissions: undefined,
+						storageOnly: false,
+					}
+				: { readonly };
+		}
+	}
+
+	/**
+	 * Called by the owning datastore context to configure the readonly
+	 * state of the delta manger that is project down to the datastore
+	 * runtime. This state may not align with that of the true delta
+	 * manager if the context wishes to control the read only state
+	 * differently than the delta manager itself.
+	 */
+	public setReadonly(
+		readonly: boolean,
+		readonlyConnectionReason?: { reason: string; error?: IErrorBase },
+	): void {
+		this.emit("readonly", readonly, readonlyConnectionReason);
+	}
+}
+
 /**
  * Represents the context for the store. This context is passed to the store runtime.
  * @internal
@@ -217,10 +276,13 @@ export abstract class FluidDataStoreContext
 		return this.parentContext.baseLogger;
 	}
 
+	private readonly _contextDeltaManagerProxy: ContextDeltaManagerProxy;
 	public get deltaManager(): IDeltaManager<ISequencedDocumentMessage, IDocumentMessage> {
-		return this.parentContext.deltaManager;
+		return this._contextDeltaManagerProxy;
 	}
 
+	public isReadOnly = (): boolean => this.parentContext.isReadOnly?.() ?? false;
+
 	public get connected(): boolean {
 		return this.parentContext.connected;
 	}
@@ -420,6 +482,16 @@ export abstract class FluidDataStoreContext
 		// By default, a data store can log maximum 10 local changes telemetry in summarizer.
 		this.localChangesTelemetryCount =
 			this.mc.config.getNumber("Fluid.Telemetry.LocalChangesTelemetryCount") ?? 10;
+
+		assert(
+			isIDeltaManagerFull(this.parentContext.deltaManager),
+			0xb83 /* Invalid delta manager */,
+		);
+
+		this._contextDeltaManagerProxy = new ContextDeltaManagerProxy(
+			this.parentContext.deltaManager,
+			() => this.isReadOnly(),
+		);
 	}
 
 	public dispose(): void {
@@ -437,6 +509,7 @@ export abstract class FluidDataStoreContext
 				})
 				.catch((error) => {});
 		}
+		this._contextDeltaManagerProxy.dispose();
 	}
 
 	/**
@@ -615,6 +688,13 @@ export abstract class FluidDataStoreContext
 		this.channel!.setConnectionState(connected, clientId);
 	}
 
+	public notifyReadOnlyState(readonly: boolean): void {
+		this.verifyNotClosed("notifyReadOnlyState", false /* checkTombstone */);
+
+		this.channel?.notifyReadOnlyState?.(readonly);
+		this._contextDeltaManagerProxy.setReadonly(readonly);
+	}
+
 	/**
 	 * Process messages for this data store. The messages here are contiguous messages for this data store in a batch.
 	 * @param messageCollection - The collection of messages to process.

package/src/deltaManagerProxies.ts

@@ -25,13 +25,68 @@ import {
 import type { PendingStateManager } from "./pendingStateManager.js";
 import { summarizerClientType } from "./summary/index.js";
 
+/**
+ * Interface defining event handlers for the BaseDeltaManagerProxy.
+ * These handlers allow customization of behavior for various DeltaManager events.
+ */
+export interface BaseDeltaManagerProxyEventHandlers {
+	/**
+	 * Event handler triggered when the readonly state changes.
+	 * @param readonly - Indicates if the connection is readonly.
+	 * @param readonlyConnectionReason - Optional reason and error details for the readonly state.
+	 */
+	onReadonly: (
+		readonly: boolean,
+		readonlyConnectionReason?: { reason: string; error?: IErrorBase },
+	) => void;
+
+	/**
+	 * Event handler triggered before sending a message.
+	 * @param messageBuffer - The buffer of messages to be sent.
+	 */
+	onPrepareSend: (messageBuffer: unknown[]) => void;
+
+	/**
+	 * Event handler triggered when an operation is submitted.
+	 * @param message - The document message being submitted.
+	 */
+	onSubmitOp: (message: IDocumentMessage) => void;
+
+	/**
+	 * Event handler triggered when an operation is received.
+	 * @param message - The sequenced document message received.
+	 * @param processingTime - The time taken to process the message.
+	 */
+	onOp: (message: ISequencedDocumentMessage, processingTime: number) => void;
+
+	/**
+	 * Event handler triggered when a pong response is received.
+	 * @param latency - The latency of the pong response.
+	 */
+	onPong: (latency: number) => void;
+
+	/**
+	 * Event handler triggered when a connection is established.
+	 * @param details - The connection details.
+	 * @param opsBehind - Optional number of operations behind the latest state.
+	 */
+	onConnect: (details: IConnectionDetails, opsBehind?: number) => void;
+
+	/**
+	 * Event handler triggered when a disconnection occurs.
+	 * @param reason - The reason for the disconnection.
+	 * @param error - Optional error details for the disconnection.
+	 */
+	onDisconnect: (reason: string, error?: IAnyDriverError) => void;
+}
+
 /**
  * Base class for DeltaManager proxy that proxy's access to the real DeltaManager.
  *
  * This class allows us to build proxy functionality without actually having to implement all the methods
  * of the DeltaManager.
  */
-export abstract class BaseDeltaManagerProxy
+export class BaseDeltaManagerProxy
 	extends TypedEventEmitter<IDeltaManagerEvents>
 	implements IDeltaManagerFull
 {
@@ -99,29 +154,64 @@ export abstract class BaseDeltaManagerProxy
 		return this.deltaManager.readOnlyInfo;
 	}
 
-	constructor(protected readonly deltaManager: IDeltaManagerFull) {
+	private readonly eventHandlers: BaseDeltaManagerProxyEventHandlers;
+
+	constructor(
+		protected readonly deltaManager: IDeltaManagerFull,
+		overrides?: Partial<BaseDeltaManagerProxyEventHandlers>,
+	) {
 		super();
 
+		this.eventHandlers = {
+			onPrepareSend: (messageBuffer: unknown[]): void => {
+				this.emit("prepareSend", messageBuffer);
+			},
+			onSubmitOp: (message: IDocumentMessage): void => {
+				this.emit("submitOp", message);
+			},
+			onOp: (message: ISequencedDocumentMessage, processingTime: number): void => {
+				this.emit("op", message, processingTime);
+			},
+			onPong: (latency: number): void => {
+				this.emit("pong", latency);
+			},
+			onConnect: (details: IConnectionDetails, opsBehind?: number): void => {
+				this.emit("connect", details, opsBehind);
+			},
+			onDisconnect: (reason: string, error?: IAnyDriverError): void => {
+				this.emit("disconnect", reason, error);
+			},
+			onReadonly: (
+				readonly: boolean,
+				readonlyConnectionReason?: { reason: string; error?: IErrorBase },
+			): void => {
+				this.emit("readonly", readonly, readonlyConnectionReason);
+			},
+
+			...overrides,
+		};
+
 		// We are expecting this class to have many listeners, so we suppress noisy "MaxListenersExceededWarning" logging.
 		super.setMaxListeners(0);
 
-		this.deltaManager.on("prepareSend", this.onPrepareSend);
-		this.deltaManager.on("submitOp", this.onSubmitOp);
-		this.deltaManager.on("op", this.onOp);
-		this.deltaManager.on("pong", this.onPong);
-		this.deltaManager.on("connect", this.onConnect);
-		this.deltaManager.on("disconnect", this.onDisconnect);
-		this.deltaManager.on("readonly", this.onReadonly);
+		this.deltaManager.on("prepareSend", this.eventHandlers.onPrepareSend);
+		this.deltaManager.on("submitOp", this.eventHandlers.onSubmitOp);
+		this.deltaManager.on("op", this.eventHandlers.onOp);
+		this.deltaManager.on("pong", this.eventHandlers.onPong);
+		this.deltaManager.on("connect", this.eventHandlers.onConnect);
+		this.deltaManager.on("disconnect", this.eventHandlers.onDisconnect);
+		this.deltaManager.on("readonly", this.eventHandlers.onReadonly);
 	}
 
 	public dispose(): void {
-		this.deltaManager.off("prepareSend", this.onPrepareSend);
-		this.deltaManager.off("submitOp", this.onSubmitOp);
-		this.deltaManager.off("op", this.onOp);
-		this.deltaManager.off("pong", this.onPong);
-		this.deltaManager.off("connect", this.onConnect);
-		this.deltaManager.off("disconnect", this.onDisconnect);
-		this.deltaManager.off("readonly", this.onReadonly);
+		this.deltaManager.off("prepareSend", this.eventHandlers.onPrepareSend);
+		this.deltaManager.off("submitOp", this.eventHandlers.onSubmitOp);
+		this.deltaManager.off("op", this.eventHandlers.onOp);
+		this.deltaManager.off("pong", this.eventHandlers.onPong);
+		this.deltaManager.off("connect", this.eventHandlers.onConnect);
+		this.deltaManager.off("disconnect", this.eventHandlers.onDisconnect);
+		this.deltaManager.off("readonly", this.eventHandlers.onReadonly);
+		this.removeAllListeners();
 	}
 
 	public submitSignal(content: string, targetClientId?: string): void {
@@ -131,34 +221,6 @@ export abstract class BaseDeltaManagerProxy
 	public flush(): void {
 		return this.deltaManager.flush();
 	}
-
-	private readonly onPrepareSend = (messageBuffer: unknown[]): void => {
-		this.emit("prepareSend", messageBuffer);
-	};
-	private readonly onSubmitOp = (message: IDocumentMessage): void => {
-		this.emit("submitOp", message);
-	};
-	protected readonly onOp = (
-		message: ISequencedDocumentMessage,
-		processingTime: number,
-	): void => {
-		this.emit("op", message, processingTime);
-	};
-	private readonly onPong = (latency: number): void => {
-		this.emit("pong", latency);
-	};
-	private readonly onConnect = (details: IConnectionDetails, opsBehind?: number): void => {
-		this.emit("connect", details, opsBehind);
-	};
-	private readonly onDisconnect = (reason: string, error?: IAnyDriverError): void => {
-		this.emit("disconnect", reason, error);
-	};
-	private readonly onReadonly = (
-		readonly: boolean,
-		readonlyConnectionReason?: { reason: string; error?: IErrorBase },
-	): void => {
-		this.emit("readonly", readonly, readonlyConnectionReason);
-	};
 }
 
 /**
@@ -167,31 +229,34 @@ export abstract class BaseDeltaManagerProxy
  * - Summarizer client should not be active to layers below the container runtime to restrict local changes.
  */
 export class DeltaManagerSummarizerProxy extends BaseDeltaManagerProxy {
+	public static wrapIfSummarizer(deltaManager: IDeltaManagerFull): IDeltaManagerFull {
+		if (deltaManager.clientDetails.type === summarizerClientType) {
+			return new DeltaManagerSummarizerProxy(deltaManager);
+		}
+		return deltaManager;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/class-literal-property-style
 	public get active(): boolean {
 		// Summarize clients should not be active. There shouldn't be any local changes (writes) in the summarizer
 		// except for the SummarizeOp which is generated by the runtime.
-		return !this.isSummarizerClient && this.deltaManager.active;
+		return false;
 	}
 
 	public get readOnlyInfo(): ReadOnlyInfo {
 		// Summarizer clients should be read-only as far as the runtime and layers below are concerned. There shouldn't
 		// be any local changes (writes) in the summarizer except for the summarize op which is generated by the runtime.
-		if (this.isSummarizerClient) {
-			return {
-				readonly: true,
-				forced: false,
-				permissions: undefined,
-				storageOnly: false,
-			};
-		}
-		return this.deltaManager.readOnlyInfo;
-	}
 
-	private readonly isSummarizerClient: boolean;
+		return {
+			readonly: true,
+			forced: false,
+			permissions: undefined,
+			storageOnly: false,
+		};
+	}
 
 	constructor(protected readonly deltaManager: IDeltaManagerFull) {
-		super(deltaManager);
-		this.isSummarizerClient = this.deltaManager.clientDetails.type === summarizerClientType;
+		super(deltaManager, { onReadonly: () => {} });
 	}
 }
 
@@ -228,17 +293,6 @@ export class DeltaManagerPendingOpsProxy extends BaseDeltaManagerProxy {
 		};
 	}
 
-	protected readonly onOp = (
-		message: ISequencedDocumentMessage,
-		processingTime: number,
-	): void => {
-		const messageIntercept = {
-			...message,
-			minimumSequenceNumber: this.minimumSequenceNumber,
-		};
-		this.emit("op", messageIntercept, processingTime);
-	};
-
 	constructor(
 		protected readonly deltaManager: IDeltaManagerFull,
 		private readonly pendingStateManager: Pick<
@@ -246,6 +300,14 @@ export class DeltaManagerPendingOpsProxy extends BaseDeltaManagerProxy {
 			"minimumPendingMessageSequenceNumber"
 		>,
 	) {
-		super(deltaManager);
+		super(deltaManager, {
+			onOp: (message: ISequencedDocumentMessage, processingTime: number): void => {
+				const messageIntercept = {
+					...message,
+					minimumSequenceNumber: this.minimumSequenceNumber,
+				};
+				this.emit("op", messageIntercept, processingTime);
+			},
+		});
 	}
 }

package/src/gc/gcDefinitions.ts

@@ -333,6 +333,8 @@ export type GarbageCollectionMessage = ISweepMessage | ITombstoneLoadedMessage;
 
 /**
  * Defines the APIs for the runtime object to be passed to the garbage collector.
+ *
+ * @internal
  */
 export interface IGarbageCollectionRuntime {
 	/**

package/src/index.ts

@@ -4,6 +4,8 @@
  */
 
 export {
+	ContainerRuntimeOptions,
+	ContainerRuntimeOptionsInternal,
 	ISummaryRuntimeOptions,
 	IContainerRuntimeOptions,
 	IContainerRuntimeOptionsInternal,
@@ -14,11 +16,10 @@ export {
 	DeletedResponseHeaderKey,
 	TombstoneResponseHeaderKey,
 	InactiveResponseHeaderKey,
-	ICompressionRuntimeOptions,
-	CompressionAlgorithms,
 	RuntimeHeaderData,
-	disabledCompressionConfig,
 } from "./containerRuntime.js";
+export type { ICompressionRuntimeOptions } from "./compressionDefinitions.js";
+export { CompressionAlgorithms, disabledCompressionConfig } from "./compressionDefinitions.js";
 export {
 	ContainerMessageType,
 	UnknownContainerRuntimeMessage,
@@ -35,6 +36,7 @@ export {
 	IGCMetadata,
 	GCFeatureMatrix,
 	GCVersion,
+	IGarbageCollectionRuntime,
 	IGCRuntimeOptions,
 	IMarkPhaseStats,
 	ISweepPhaseStats,

package/src/opLifecycle/batchManager.ts

@@ -10,20 +10,15 @@ import {
 	TelemetryDataTag,
 } from "@fluidframework/telemetry-utils/internal";
 
-import { ICompressionRuntimeOptions } from "../containerRuntime.js";
+import { ICompressionRuntimeOptions } from "../compressionDefinitions.js";
 import { asBatchMetadata, type IBatchMetadata } from "../metadata.js";
 import type { IPendingMessage } from "../pendingStateManager.js";
 
-import {
-	LocalBatchMessage,
-	IBatchCheckpoint,
-	type LocalBatch,
-	type OutboundBatch,
-} from "./definitions.js";
+import { LocalBatchMessage, IBatchCheckpoint, type LocalBatch } from "./definitions.js";
+import { serializeOp } from "./opSerialization.js";
 import type { BatchStartInfo } from "./remoteMessageProcessor.js";
 
 export interface IBatchManagerOptions {
-	readonly hardLimit: number;
 	readonly compressionOptions?: ICompressionRuntimeOptions;
 
 	/**
@@ -78,26 +73,16 @@ export function getEffectiveBatchId(
 	return batchStart.batchId ?? generateBatchId(batchStart.clientId, batchStart.batchStartCsn);
 }
 
-/**
- * Estimated size of the stringification overhead for an op accumulated
- * from runtime to loader to the service.
- */
-const opOverhead = 200;
-
 /**
  * Helper class that manages partial batch & rollback.
  */
 export class BatchManager {
 	private pendingBatch: LocalBatchMessage[] = [];
-	private batchContentSize = 0;
 	private hasReentrantOps = false;
 
 	public get length(): number {
 		return this.pendingBatch.length;
 	}
-	public get contentSizeInBytes(): number {
-		return this.batchContentSize;
-	}
 
 	public get sequenceNumbers(): BatchSequenceNumbers {
 		return {
@@ -125,29 +110,14 @@ export class BatchManager {
 		message: LocalBatchMessage,
 		reentrant: boolean,
 		currentClientSequenceNumber?: number,
-	): boolean {
-		const contentSize = this.batchContentSize + (message.serializedOp?.length ?? 0);
-		const opCount = this.pendingBatch.length;
+	): void {
 		this.hasReentrantOps = this.hasReentrantOps || reentrant;
 
-		// Attempt to estimate batch size, aka socket message size.
-		// Each op has pretty large envelope, estimating to be 200 bytes.
-		// Also content will be strigified, and that adds a lot of overhead due to a lot of escape characters.
-		// Not taking it into account, as compression work should help there - compressed payload will be
-		// initially stored as base64, and that requires only 2 extra escape characters.
-		const socketMessageSize = contentSize + opOverhead * opCount;
-
-		if (socketMessageSize >= this.options.hardLimit) {
-			return false;
-		}
-
 		if (this.pendingBatch.length === 0) {
 			this.clientSequenceNumber = currentClientSequenceNumber;
 		}
 
-		this.batchContentSize = contentSize;
 		this.pendingBatch.push(message);
-		return true;
 	}
 
 	public get empty(): boolean {
@@ -158,15 +128,15 @@ export class BatchManager {
 	 * Gets the pending batch and clears state for the next batch.
 	 */
 	public popBatch(batchId?: BatchId): LocalBatch {
+		assert(this.pendingBatch[0] !== undefined, 0xb8a /* expected non-empty batch */);
 		const batch: LocalBatch = {
 			messages: this.pendingBatch,
-			contentSizeInBytes: this.batchContentSize,
 			referenceSequenceNumber: this.referenceSequenceNumber,
 			hasReentrantOps: this.hasReentrantOps,
+			staged: this.pendingBatch[0].staged,
 		};
 
 		this.pendingBatch = [];
-		this.batchContentSize = 0;
 		this.clientSequenceNumber = undefined;
 		this.hasReentrantOps = false;
 
@@ -184,7 +154,6 @@ export class BatchManager {
 				this.clientSequenceNumber = startSequenceNumber;
 				const rollbackOpsLifo = this.pendingBatch.splice(startPoint).reverse();
 				for (const message of rollbackOpsLifo) {
-					this.batchContentSize -= message.serializedOp?.length ?? 0;
 					process(message);
 				}
 				const count = this.pendingBatch.length - startPoint;
@@ -192,9 +161,7 @@ export class BatchManager {
 					throw new LoggingError("Ops generated during rollback", {
 						count,
 						...tagData(TelemetryDataTag.UserData, {
-							ops: JSON.stringify(
-								this.pendingBatch.slice(startPoint).map((b) => b.serializedOp),
-							),
+							ops: serializeOp(this.pendingBatch.slice(startPoint).map((b) => b.runtimeOp)),
 						}),
 					});
 				}
@@ -233,18 +200,6 @@ const addBatchMetadata = (batch: LocalBatch, batchId?: BatchId): LocalBatch => {
 	return batch;
 };
 
-/**
- * Estimates the real size in bytes on the socket for a given batch. It assumes that
- * the envelope size (and the size of an empty op) is 200 bytes, taking into account
- * extra overhead from stringification.
- *
- * @param batch - the batch to inspect
- * @returns An estimate of the payload size in bytes which will be produced when the batch is sent over the wire
- */
-export const estimateSocketSize = (batch: OutboundBatch): number => {
-	return batch.contentSizeInBytes + opOverhead * batch.messages.length;
-};
-
 export const sequenceNumbersMatch = (
 	seqNums: BatchSequenceNumbers,
 	otherSeqNums: BatchSequenceNumbers,

package/src/opLifecycle/definitions.ts

@@ -5,17 +5,33 @@
 
 import type { IBatchMessage } from "@fluidframework/container-definitions/internal";
 
-import { CompressionAlgorithms } from "../containerRuntime.js";
+import { CompressionAlgorithms } from "../compressionDefinitions.js";
+import type { LocalContainerRuntimeMessage } from "../messageTypes.js";
 
 /**
  * Local Batch message, before it is virtualized and sent to the ordering service
  */
 export interface LocalBatchMessage {
-	serializedOp: string;
+	/**
+	 * The original local op
+	 */
+	runtimeOp: LocalContainerRuntimeMessage;
+	/**
+	 * Optional metadata which is not to be serialized with the op, and is visible to the ordering service
+	 */
 	metadata?: Record<string, unknown>;
+	/**
+	 * Metadata used by this local client in flows such as rebase
+	 */
 	localOpMetadata?: unknown;
+	/**
+	 * Reference sequence number this op is based on
+	 */
 	referenceSequenceNumber: number;
-	compression?: CompressionAlgorithms;
+	/**
+	 * If true, this op is not to be submitted to the ordering service yet, since it was submitted during Staging Mode
+	 */
+	staged?: boolean;
 
 	/**
 	 * @deprecated Use serializedOp
@@ -23,6 +39,15 @@ export interface LocalBatchMessage {
 	contents?: never; // To ensure we don't leave this one when converting from OutboundBatchMessage
 }
 
+/**
+ * Placeholder for an empty batch, for tracking the pending local empty batch
+ */
+export interface LocalEmptyBatchPlaceholder {
+	metadata?: Record<string, unknown>;
+	localOpMetadata: { emptyBatch: true };
+	referenceSequenceNumber: number;
+}
+
 /**
  * Virtualized Batch message, on its way out the door to the ordering service
  */
@@ -40,30 +65,39 @@ export type OutboundBatchMessage = IBatchMessage & {
 /**
  * A batch of messages we have accumulated locally, but haven't sent to the ordering service yet.
  */
-export type LocalBatch = IBatch<LocalBatchMessage[]>;
+export interface LocalBatch extends IBatch<LocalBatchMessage[]> {
+	/**
+	 * If true, this batch is not to be submitted to the ordering service yet, since it was submitted during Staging Mode
+	 */
+	staged?: boolean;
+}
 
 /**
  * A batch of messages that has been virtualized as needed (grouped, compressed, chunked)
  * and is ready to be sent to the ordering service.
+ * At the very least, the op contents have been serialized to string.
  */
-export type OutboundBatch = IBatch<OutboundBatchMessage[]>;
+export interface OutboundBatch<
+	TMessages extends OutboundBatchMessage[] = OutboundBatchMessage[],
+> extends IBatch<TMessages> {
+	/**
+	 * Sum of the in-memory content sizes of all messages in the batch.
+	 * If the batch is compressed, this number reflects the post-compression size.
+	 */
+	readonly contentSizeInBytes: number;
+}
 
 /**
  * An {@link OutboundBatch} with exactly one message
  * This type is helpful as Grouping yields this kind of batch, and Compression only operates on this type of batch.
  */
-export type OutboundSingletonBatch = IBatch<[OutboundBatchMessage]>;
+export type OutboundSingletonBatch = OutboundBatch<[OutboundBatchMessage]>;
 
 /**
  * Base batch interface used internally by the runtime.
  * See {@link LocalBatch} and {@link OutboundBatch} for the concrete types.
  */
 interface IBatch<TMessages extends LocalBatchMessage[] | OutboundBatchMessage[]> {
-	/**
-	 * Sum of the in-memory content sizes of all messages in the batch.
-	 * If the batch is compressed, this number reflects the post-compression size.
-	 */
-	readonly contentSizeInBytes: number;
 	/**
 	 * All the messages in the batch
 	 */