@fluidframework/container-runtime 2.31.1 → 2.33.0-333010

package/src/opLifecycle/opSplitter.ts

@@ -16,8 +16,12 @@ import {
 
 import { ContainerMessageType, ContainerRuntimeChunkedOpMessage } from "../messageTypes.js";
 
-import { estimateSocketSize } from "./batchManager.js";
-import { BatchMessage, IBatch, IChunkedOp } from "./definitions.js";
+import {
+	IChunkedOp,
+	type OutboundBatchMessage,
+	type OutboundSingletonBatch,
+} from "./definitions.js";
+import { estimateSocketSize } from "./outbox.js";
 
 export function isChunkedMessage(message: ISequencedDocumentMessage): boolean {
 	return isChunkedContents(message.contents);
@@ -96,8 +100,8 @@ export class OpSplitter {
 	}
 
 	/**
-	 * Splits the first op of a compressed batch in chunks, sends the chunks separately and
-	 * returns a new batch composed of the last chunk and the rest of the ops in the original batch.
+	 * Takes a singleton batch, and splits the interior message into chunks, sending the chunks separately and
+	 * returning a new singleton batch containing the last chunk.
 	 *
 	 * A compressed batch is formed by one large op at the first position.
 	 *
@@ -108,21 +112,20 @@ export class OpSplitter {
 	 * This will ensure that the batch semantics of the original (non-compressed) batch are preserved, as the original chunked op
 	 * will be unrolled by the runtime when the first message in the batch is processed (as it is the last chunk).
 	 *
-	 * To handle legacy compressed batches with empty placeholders this method can attach the empty placeholder ops at the end
-	 * of the result batch, ensuring that the batch semantics are preserved.
-	 *
 	 * To illustrate the current functionality, if the input is `[largeOp]`, `largeOp` will be split into `[chunk1, chunk2, chunk3, chunk4]`.
 	 * `chunk1`, `chunk2` and `chunk3` will be sent individually and `[chunk4]` will be returned.
 	 *
-	 * With the legacy code, if the input is `[largeOp, emptyOp, emptyOp]`, `largeOp` will be split into `[chunk1, chunk2, chunk3, chunk4]`.
-	 * `chunk1`, `chunk2` and `chunk3` will be sent individually and `[chunk4, emptyOp, emptyOp]` will be returned.
-	 *
 	 * @remarks - A side effect here is that 1 or more chunks are queued immediately for sending in next JS turn.
 	 *
-	 * @param batch - the compressed batch which needs to be processed
-	 * @returns A batch with the last chunk of the original message
+	 * @privateRemarks
+	 * This maintains support for splitting a compressed batch with multiple messages (empty placeholders after the first),
+	 * but this is only used for Unit Tests so the typing has been updated to preclude that.
+	 * That code should be moved out of this function into a test helper.
+	 *
+	 * @param batch - the compressed batch which needs to be split into chunks before being sent over the wire
+	 * @returns A batch with the last chunk in place of the original complete compressed content
 	 */
-	public splitFirstBatchMessage(batch: IBatch): IBatch {
+	public splitSingletonBatchMessage(batch: OutboundSingletonBatch): OutboundSingletonBatch {
 		assert(this.isBatchChunkingEnabled, 0x513 /* Chunking needs to be enabled */);
 		assert(
 			batch.contentSizeInBytes > 0 && batch.messages.length > 0,
@@ -138,13 +141,14 @@ export class OpSplitter {
 			0x516 /* Chunk size needs to be smaller than the max batch size */,
 		);
 
-		const firstMessage = batch.messages[0]; // we expect this to be the large compressed op, which needs to be split
+		// first message is the large compressed op to split, and we expect restOfMessages to be empty
+		// (but we keep it here to support a legacy test case, wherein it contains empty placeholder messages)
+		const [firstMessage, ...restOfMessages] = batch.messages;
 		assert(
 			(firstMessage.contents?.length ?? 0) >= this.chunkSizeInBytes,
 			0x518 /* First message in the batch needs to be chunkable */,
 		);
 
-		const restOfMessages = batch.messages.slice(1); // we expect these to be empty ops, created to reserve sequence numbers
 		const socketSize = estimateSocketSize(batch);
 		const chunks = splitOp(
 			firstMessage,
@@ -243,7 +247,7 @@ const chunkToBatchMessage = (
 	chunk: IChunkedOp,
 	referenceSequenceNumber: number,
 	metadata: Record<string, unknown> | undefined = undefined,
-): BatchMessage => {
+): OutboundBatchMessage => {
 	const payload: ContainerRuntimeChunkedOpMessage = {
 		type: ContainerMessageType.ChunkedOp,
 		contents: chunk,
@@ -268,7 +272,7 @@ const chunkToBatchMessage = (
  * @returns an array of chunked ops
  */
 export const splitOp = (
-	op: BatchMessage,
+	op: OutboundBatchMessage,
 	chunkSizeInBytes: number,
 	extraOp: boolean = false,
 ): IChunkedOp[] => {

package/src/opLifecycle/outbox.ts

@@ -3,35 +3,40 @@
  * 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 {
+	ITelemetryBaseLogger,
+	type ITelemetryBaseProperties,
+} from "@fluidframework/core-interfaces";
 import { assert, Lazy } from "@fluidframework/core-utils/internal";
 import {
 	DataProcessingError,
-	GenericError,
 	UsageError,
 	createChildLogger,
+	type IFluidErrorBase,
 	type ITelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
 
 import { ICompressionRuntimeOptions } from "../containerRuntime.js";
-import { OutboundContainerRuntimeMessage } from "../messageTypes.js";
 import { PendingMessageResubmitData, PendingStateManager } from "../pendingStateManager.js";
 
 import {
 	BatchManager,
 	BatchSequenceNumbers,
-	estimateSocketSize,
 	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 +58,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 +67,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);
 }
 
 /**
@@ -112,6 +108,55 @@ export function getLongStack<T>(action: () => T, length: number = 50): T {
 	}
 }
 
+/**
+ * Convert from local batch to outbound batch, including computing contentSizeInBytes.
+ */
+export function localBatchToOutboundBatch(localBatch: LocalBatch): OutboundBatch {
+	// Shallow copy each message as we switch types
+	const outboundMessages = localBatch.messages.map<OutboundBatchMessage>(
+		({ serializedOp, ...message }) => ({
+			contents: serializedOp,
+			...message,
+		}),
+	);
+	const contentSizeInBytes = outboundMessages.reduce(
+		(acc, message) => acc + (message.contents?.length ?? 0),
+		0,
+	);
+
+	// Shallow copy the local batch, updating the messages to be outbound messages and adding contentSizeInBytes
+	const outboundBatch: OutboundBatch = {
+		...localBatch,
+		messages: outboundMessages,
+		contentSizeInBytes,
+	};
+
+	return outboundBatch;
+}
+
+/**
+ * Estimated size of the stringification overhead for an op accumulated
+ * from runtime to loader to the service.
+ */
+const opOverhead = 200;
+
+/**
+ * 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.
+ *
+ * @remarks
+ * Also content will be stringified, 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.
+ *
+ * @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;
+};
+
 /**
  * The Outbox collects messages submitted by the ContainerRuntime into a batch,
  * and then flushes the batch when requested.
@@ -139,18 +184,9 @@ export class Outbox {
 	constructor(private readonly params: IOutboxParameters) {
 		this.logger = createChildLogger({ logger: params.logger, namespace: "Outbox" });
 
-		const isCompressionEnabled =
-			this.params.config.compressionOptions.minimumBatchSizeInBytes !==
-			Number.POSITIVE_INFINITY;
-		// We need to allow infinite size batches if we enable compression
-		const hardLimit = isCompressionEnabled
-			? Number.POSITIVE_INFINITY
-			: this.params.config.maxBatchSizeInBytes;
-
-		this.mainBatch = new BatchManager({ hardLimit, canRebase: true });
-		this.blobAttachBatch = new BatchManager({ hardLimit, canRebase: true });
+		this.mainBatch = new BatchManager({ canRebase: true });
+		this.blobAttachBatch = new BatchManager({ canRebase: true });
 		this.idAllocationBatch = new BatchManager({
-			hardLimit,
 			canRebase: false,
 			ignoreBatchId: true,
 		});
@@ -258,53 +294,48 @@ 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 {
-		if (
-			!batchManager.push(
-				message,
-				this.isContextReentrant(),
-				this.params.getCurrentSequenceNumbers().clientSequenceNumber,
-			)
-		) {
-			throw new GenericError("BatchTooLarge", /* error */ undefined, {
-				opSize: message.contents?.length ?? 0,
-				batchSize: batchManager.contentSizeInBytes,
-				count: batchManager.length,
-				limit: batchManager.options.hardLimit,
-			});
-		}
+	private addMessageToBatchManager(
+		batchManager: BatchManager,
+		message: LocalBatchMessage,
+	): void {
+		batchManager.push(
+			message,
+			this.isContextReentrant(),
+			this.params.getCurrentSequenceNumbers().clientSequenceNumber,
+		);
 	}
 
 	/**
 	 * 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 +377,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 +405,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 +428,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 +450,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,44 +484,56 @@ 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 = localBatchToOutboundBatch(localBatch);
+
+		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);
 		}
 
+		// We want to distinguish this "BatchTooLarge" case from the generic "BatchTooLarge" case in sendBatch
 		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 this.makeBatchTooLargeError(compressedBatch, "CompressionInsufficient", {
+				uncompressedSizeInBytes: singletonBatch.contentSizeInBytes,
 			});
 		}
 
@@ -497,7 +546,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
@@ -505,12 +554,7 @@ export class Outbox {
 
 		const socketSize = estimateSocketSize(batch);
 		if (socketSize >= this.params.config.maxBatchSizeInBytes) {
-			this.logger.sendPerformanceEvent({
-				eventName: "LargeBatch",
-				length: batch.messages.length,
-				sizeInBytes: batch.contentSizeInBytes,
-				socketSize,
-			});
+			throw this.makeBatchTooLargeError(batch, "CannotSend");
 		}
 
 		let clientSequenceNumber: number;
@@ -542,6 +586,31 @@ export class Outbox {
 		return clientSequenceNumber;
 	}
 
+	private makeBatchTooLargeError(
+		batch: OutboundBatch,
+		codepath: string,
+		moreDetails?: ITelemetryBaseProperties,
+	): IFluidErrorBase {
+		return DataProcessingError.create(
+			"BatchTooLarge",
+			codepath,
+			/* sequencedMessage */ undefined,
+			{
+				errorDetails: {
+					opCount: batch.messages.length,
+					contentSizeInBytes: batch.contentSizeInBytes,
+					socketSize: estimateSocketSize(batch),
+					maxBatchSizeInBytes: this.params.config.maxBatchSizeInBytes,
+					groupedBatchingEnabled: this.params.groupingManager.groupedBatchingEnabled(),
+					compressionOptions: JSON.stringify(this.params.config.compressionOptions),
+					chunkingEnabled: this.params.splitter.isBatchChunkingEnabled,
+					chunkSizeInBytes: this.params.splitter.chunkSizeInBytes,
+					...moreDetails,
+				},
+			},
+		);
+	}
+
 	/**
 	 * Gets a checkpoint object per batch that facilitates iterating over the batch messages when rolling back.
 	 */

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.1";
+export const pkgVersion = "2.33.0-333010";

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]),
 };
 
 /**