@fluidframework/container-runtime 2.51.0 → 2.53.0-350190

package/src/blobManager/blobManager.ts

@@ -3,8 +3,11 @@
  * Licensed under the MIT License.
  */
 
-import { bufferToString, createEmitter, stringToBuffer } from "@fluid-internal/client-utils";
-import { AttachState } from "@fluidframework/container-definitions";
+import { createEmitter } from "@fluid-internal/client-utils";
+import {
+	AttachState,
+	type IContainerStorageService,
+} from "@fluidframework/container-definitions/internal";
 import {
 	IContainerRuntime,
 	IContainerRuntimeEvents,
@@ -20,10 +23,7 @@ import type {
 	PayloadState,
 } from "@fluidframework/core-interfaces/internal";
 import { assert, Deferred } from "@fluidframework/core-utils/internal";
-import {
-	IDocumentStorageService,
-	ICreateBlobResponse,
-} from "@fluidframework/driver-definitions/internal";
+import { ICreateBlobResponse } from "@fluidframework/driver-definitions/internal";
 import { canRetryOnError, runWithRetry } from "@fluidframework/driver-utils/internal";
 import {
 	IGarbageCollectionData,
@@ -41,12 +41,13 @@ import {
 	LoggingError,
 	MonitoringContext,
 	PerformanceEvent,
+	UsageError,
 	createChildMonitoringContext,
 	wrapError,
 } from "@fluidframework/telemetry-utils/internal";
 import { v4 as uuid } from "uuid";
 
-import { IBlobMetadata } from "../metadata.js";
+import { isBlobMetadata } from "../metadata.js";
 
 import {
 	getStorageIds,
@@ -148,7 +149,6 @@ interface PendingBlob {
 	attached?: boolean;
 	acked?: boolean;
 	abortSignal?: AbortSignal;
-	stashedUpload?: boolean;
 }
 
 export interface IPendingBlobs {
@@ -171,16 +171,6 @@ interface IBlobManagerInternalEvents {
 	processedBlobAttach: (localId: string, storageId: string) => void;
 }
 
-const stashedPendingBlobOverrides: Pick<
-	PendingBlob,
-	"stashedUpload" | "storageId" | "minTTLInSeconds" | "uploadTime"
-> = {
-	stashedUpload: true,
-	storageId: undefined,
-	minTTLInSeconds: undefined,
-	uploadTime: undefined,
-} as const;
-
 export const blobManagerBasePath = "_blobs" as const;
 
 export class BlobManager {
@@ -213,11 +203,10 @@ export class BlobManager {
 	 */
 	private readonly opsInFlight: Map<string, Set<string>> = new Map();
 
-	private readonly sendBlobAttachOp: (localId: string, storageId?: string) => void;
-	private stopAttaching: boolean = false;
+	private readonly sendBlobAttachOp: (localId: string, storageId: string) => void;
 
 	private readonly routeContext: IFluidHandleContext;
-	private readonly storage: IDocumentStorageService;
+	private readonly storage: Pick<IContainerStorageService, "createBlob" | "readBlob">;
 	// Called when a blob node is requested. blobPath is the path of the blob's node in GC's graph.
 	// blobPath's format - `/<basePath>/<blobId>`.
 	private readonly blobRequested: (blobPath: string) => void;
@@ -226,9 +215,6 @@ export class BlobManager {
 	private readonly isBlobDeleted: (blobPath: string) => boolean;
 	private readonly runtime: IBlobManagerRuntime;
 	private readonly localBlobIdGenerator: () => string;
-	private readonly pendingStashedBlobs: Map<string, Promise<ICreateBlobResponse | void>> =
-		new Map();
-	public readonly stashedBlobsUploadP: Promise<(void | ICreateBlobResponse)[]>;
 
 	private readonly createBlobPayloadPending: boolean;
 
@@ -236,7 +222,7 @@ export class BlobManager {
 		readonly routeContext: IFluidHandleContext;
 
 		blobManagerLoadInfo: IBlobManagerLoadInfo;
-		readonly storage: IDocumentStorageService;
+		readonly storage: Pick<IContainerStorageService, "createBlob" | "readBlob">;
 		/**
 		 * Submit a BlobAttach op. When a blob is uploaded, there is a short grace period before which the blob is
 		 * deleted. The BlobAttach op notifies the server that blob is in use. The server will then not delete the
@@ -247,7 +233,7 @@ export class BlobManager {
 		 * knowledge of which they cannot request the blob from storage. It's important that this op is sequenced
 		 * before any ops that reference the local ID, otherwise, an invalid handle could be added to the document.
 		 */
-		sendBlobAttachOp: (localId: string, storageId?: string) => void;
+		sendBlobAttachOp: (localId: string, storageId: string) => void;
 		// Called when a blob node is requested. blobPath is the path of the blob's node in GC's graph.
 		// blobPath's format - `/<basePath>/<blobId>`.
 		readonly blobRequested: (blobPath: string) => void;
@@ -267,7 +253,6 @@ export class BlobManager {
 			blobRequested,
 			isBlobDeleted,
 			runtime,
-			stashedBlobs,
 			localBlobIdGenerator,
 			createBlobPayloadPending,
 		} = props;
@@ -290,48 +275,7 @@ export class BlobManager {
 			this.runtime.attachState,
 		);
 
-		// Begin uploading stashed blobs from previous container instance
-		for (const [localId, entry] of Object.entries(stashedBlobs ?? {})) {
-			const { acked, storageId, minTTLInSeconds, uploadTime } = entry;
-			const blob = stringToBuffer(entry.blob, "base64");
-			const pendingEntry: PendingBlob = {
-				blob,
-				opsent: true,
-				handleP: new Deferred(),
-				storageId,
-				uploadP: undefined,
-				uploadTime,
-				minTTLInSeconds,
-				attached: true,
-				acked,
-			};
-			this.pendingBlobs.set(localId, pendingEntry);
-
-			if (storageId !== undefined && minTTLInSeconds && uploadTime) {
-				const timeLapseSinceLocalUpload = (Date.now() - uploadTime) / 1000;
-				// stashed entries with more than half-life in storage will not be reuploaded
-				if (minTTLInSeconds - timeLapseSinceLocalUpload > minTTLInSeconds / 2) {
-					continue;
-				}
-			}
-			this.pendingStashedBlobs.set(localId, this.uploadBlob(localId, blob));
-			this.pendingBlobs.set(localId, {
-				...pendingEntry,
-				...stashedPendingBlobOverrides,
-				uploadP: this.pendingStashedBlobs.get(localId),
-			});
-		}
-
-		this.stashedBlobsUploadP = PerformanceEvent.timedExecAsync(
-			this.mc.logger,
-			{ eventName: "BlobUploadProcessStashedChanges", count: this.pendingStashedBlobs.size },
-			async () => Promise.all(this.pendingStashedBlobs.values()),
-			{ start: true, end: true },
-		).finally(() => {
-			this.pendingStashedBlobs.clear();
-		});
-
-		this.sendBlobAttachOp = (localId: string, blobId?: string) => {
+		this.sendBlobAttachOp = (localId: string, blobId: string) => {
 			const pendingEntry = this.pendingBlobs.get(localId);
 			assert(
 				pendingEntry !== undefined,
@@ -387,10 +331,6 @@ export class BlobManager {
 		});
 	}
 
-	public hasPendingStashedUploads(): boolean {
-		return [...this.pendingBlobs.values()].some((e) => e.stashedUpload === true);
-	}
-
 	public hasBlob(blobId: string): boolean {
 		return this.redirectTable.get(blobId) !== undefined;
 	}
@@ -420,7 +360,7 @@ export class BlobManager {
 			assert(this.redirectTable.has(blobId), 0x383 /* requesting unknown blobs */);
 
 			// Blobs created while the container is detached are stored in IDetachedBlobStorage.
-			// The 'IDocumentStorageService.readBlob()' call below will retrieve these via localId.
+			// The 'IContainerStorageService.readBlob()' call below will retrieve these via localId.
 			storageId = blobId;
 		} else {
 			const attachedStorageId = this.redirectTable.get(blobId);
@@ -491,7 +431,7 @@ export class BlobManager {
 		blob: ArrayBufferLike,
 	): Promise<IFluidHandleInternalPayloadPending<ArrayBufferLike>> {
 		// Blobs created while the container is detached are stored in IDetachedBlobStorage.
-		// The 'IDocumentStorageService.createBlob()' call below will respond with a localId.
+		// The 'IContainerStorageService.createBlob()' call below will respond with a localId.
 		const response = await this.storage.createBlob(blob);
 		this.setRedirection(response.id, undefined);
 		return this.getBlobHandle(response.id);
@@ -671,18 +611,9 @@ export class BlobManager {
 		response: ICreateBlobResponseWithTTL,
 	): ICreateBlobResponseWithTTL | undefined {
 		const entry = this.pendingBlobs.get(localId);
-		if (entry === undefined && this.pendingStashedBlobs.has(localId)) {
-			// The blob was already processed and deleted. This can happen if the blob was reuploaded by
-			// the stashing process and the original upload was processed before the stashed upload.
-			this.mc.logger.sendTelemetryEvent({
-				eventName: "StashedBlobAlreadyProcessed",
-				localId,
-			});
-			return;
-		}
 
 		assert(entry !== undefined, 0x6c8 /* pending blob entry not found for uploaded blob */);
-		if ((entry.abortSignal?.aborted === true && !entry.opsent) || this.stopAttaching) {
+		if (entry.abortSignal?.aborted === true && !entry.opsent) {
 			this.mc.logger.sendTelemetryEvent({
 				eventName: "BlobAborted",
 				localId,
@@ -694,7 +625,6 @@ export class BlobManager {
 			entry.storageId === undefined,
 			0x386 /* Must have pending blob entry for uploaded blob */,
 		);
-		entry.stashedUpload = undefined;
 		entry.storageId = response.id;
 		entry.uploadTime = Date.now();
 		entry.minTTLInSeconds = response.minTTLInSeconds;
@@ -738,46 +668,35 @@ export class BlobManager {
 	 * @param metadata - op metadata containing storage and/or local IDs
 	 */
 	public reSubmit(metadata: Record<string, unknown> | undefined): void {
-		assert(!!metadata, 0x38b /* Resubmitted ops must have metadata */);
-		const { localId, blobId }: { localId?: string; blobId?: string } = metadata;
-		assert(localId !== undefined, 0x50d /* local ID not available on reSubmit */);
-		const pendingEntry = this.pendingBlobs.get(localId);
-
-		if (!blobId) {
-			// We submitted this op while offline. The blob should have been uploaded by now.
-			assert(
-				pendingEntry?.opsent === true && !!pendingEntry?.storageId,
-				0x38d /* blob must be uploaded before resubmitting BlobAttach op */,
-			);
-			return this.sendBlobAttachOp(localId, pendingEntry?.storageId);
+		assert(isBlobMetadata(metadata), 0xc01 /* Expected blob metadata for a BlobAttach op */);
+		const { localId, blobId } = metadata;
+		// Any blob that we're actively trying to advance to attached state must have a
+		// pendingBlobs entry. Decline to resubmit for anything else.
+		// For example, we might be asked to resubmit stashed ops for blobs that never had
+		// their handle attached - these won't have a pendingBlobs entry and we shouldn't
+		// try to attach them since they won't be accessible to the customer and would just
+		// be considered garbage immediately.
+		if (this.pendingBlobs.has(localId)) {
+			this.sendBlobAttachOp(localId, blobId);
 		}
-		return this.sendBlobAttachOp(localId, blobId);
 	}
 
 	public processBlobAttachMessage(message: ISequencedMessageEnvelope, local: boolean): void {
-		const localId = (message.metadata as IBlobMetadata | undefined)?.localId;
-		const blobId = (message.metadata as IBlobMetadata | undefined)?.blobId;
-
-		if (localId) {
-			const pendingEntry = this.pendingBlobs.get(localId);
-			if (pendingEntry?.abortSignal?.aborted) {
-				this.deletePendingBlob(localId);
-				return;
-			}
-		}
-		assert(blobId !== undefined, 0x12a /* "Missing blob id on metadata" */);
-
-		// Set up a mapping from local ID to storage ID. This is crucial since without this the blob cannot be
-		// requested from the server.
-		// Note: The check for undefined is needed for back-compat when localId was not part of the BlobAttach op that
-		// was sent when online.
-		if (localId !== undefined) {
-			this.setRedirection(localId, blobId);
+		assert(
+			isBlobMetadata(message.metadata),
+			0xc02 /* Expected blob metadata for a BlobAttach op */,
+		);
+		const { localId, blobId } = message.metadata;
+		const pendingEntry = this.pendingBlobs.get(localId);
+		if (pendingEntry?.abortSignal?.aborted) {
+			this.deletePendingBlob(localId);
+			return;
 		}
+
+		this.setRedirection(localId, blobId);
 		// set identity (id -> id) entry
 		this.setRedirection(blobId, blobId);
 
-		assert(localId !== undefined, 0x50e /* local ID not present in blob attach message */);
 		if (local) {
 			const waitingBlobs = this.opsInFlight.get(blobId);
 			if (waitingBlobs !== undefined) {
@@ -950,6 +869,21 @@ export class BlobManager {
 		}
 	}
 
+	/**
+	 * To be used in getPendingLocalState flow. Get a serializable record of the blobs that are
+	 * pending upload and/or their BlobAttach op, which can be given to a new BlobManager to
+	 * resume work.
+	 *
+	 * @privateRemarks
+	 * For now, we don't track any pending blobs since the getPendingBlobs flow doesn't enable
+	 * restoring to a state where an accessible handle has been stored by the customer (and we'll
+	 * just drop any BlobAttach ops on the ground during reSubmit). However, once we add support
+	 * for payload-pending handles, this will return the blobs associated with those handles.
+	 */
+	public getPendingBlobs(): IPendingBlobs | undefined {
+		return undefined;
+	}
+
 	/**
 	 * Part of container serialization when imminent closure is enabled (Currently when calling closeAndGetPendingLocalState).
 	 * This asynchronous function resolves all pending createBlob calls and waits for each blob
@@ -963,83 +897,7 @@ export class BlobManager {
 	public async attachAndGetPendingBlobs(
 		stopBlobAttachingSignal?: AbortSignal,
 	): Promise<IPendingBlobs | undefined> {
-		return PerformanceEvent.timedExecAsync(
-			this.mc.logger,
-			{ eventName: "GetPendingBlobs" },
-			async () => {
-				if (this.pendingBlobs.size === 0) {
-					return;
-				}
-				const blobs = {};
-				const localBlobs = new Set<PendingBlob>();
-				// This while is used to stash blobs created while attaching and getting blobs
-				while (localBlobs.size < this.pendingBlobs.size) {
-					const attachHandlesP: Promise<void>[] = [];
-					for (const [localId, entry] of this.pendingBlobs) {
-						if (!localBlobs.has(entry)) {
-							localBlobs.add(entry);
-							// In order to follow natural blob creation flow we need to:
-							// 1 send the blob attach op
-							// 2 resolve the blob handle
-							// 3 wait for op referencing the blob
-							if (!entry.opsent) {
-								this.sendBlobAttachOp(localId, entry.storageId);
-							}
-							// Resolving the blob handle to let hosts continue with their operations (it will resolve
-							// original createBlob call) and let them attach the blob. This is a lie we told since the upload
-							// hasn't finished yet, but it's fine since we will retry on rehydration.
-							entry.handleP.resolve(this.getBlobHandle(localId));
-							// Array of promises that will resolve when handles get attached.
-							attachHandlesP.push(
-								new Promise<void>((resolve, reject) => {
-									stopBlobAttachingSignal?.addEventListener(
-										"abort",
-										() => {
-											this.stopAttaching = true;
-											reject(new Error("Operation aborted"));
-										},
-										{ once: true },
-									);
-									const onHandleAttached = (attachedEntry: PendingBlob): void => {
-										if (attachedEntry === entry) {
-											this.internalEvents.off("handleAttached", onHandleAttached);
-											resolve();
-										}
-									};
-									if (entry.attached) {
-										resolve();
-									} else {
-										this.internalEvents.on("handleAttached", onHandleAttached);
-									}
-								}),
-							);
-						}
-					}
-					// Wait for all blobs to be attached. This is important, otherwise serialized container
-					// could send the blobAttach op without any op that references the blob, making it useless.
-					await Promise.allSettled(attachHandlesP);
-				}
-
-				for (const [localId, entry] of this.pendingBlobs) {
-					if (stopBlobAttachingSignal?.aborted && !entry.attached) {
-						this.mc.logger.sendTelemetryEvent({
-							eventName: "UnableToStashBlob",
-							id: localId,
-						});
-						continue;
-					}
-					assert(entry.attached === true, 0x790 /* stashed blob should be attached */);
-					blobs[localId] = {
-						blob: bufferToString(entry.blob, "base64"),
-						storageId: entry.storageId,
-						acked: entry.acked,
-						minTTLInSeconds: entry.minTTLInSeconds,
-						uploadTime: entry.uploadTime,
-					};
-				}
-				return Object.keys(blobs).length > 0 ? blobs : undefined;
-			},
-		);
+		throw new UsageError("attachAndGetPendingBlobs is no longer supported");
 	}
 }
 

package/src/containerCompatibility.ts

@@ -0,0 +1,176 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	FlushMode,
+	type MinimumVersionForCollab,
+} from "@fluidframework/runtime-definitions/internal";
+import {
+	configValueToMinVersionForCollab,
+	getConfigsForMinVersionForCollab,
+	getValidationForRuntimeOptions,
+	type ConfigMap,
+	type ConfigValidationMap,
+} from "@fluidframework/runtime-utils/internal";
+
+import {
+	disabledCompressionConfig,
+	enabledCompressionConfig,
+} from "./compressionDefinitions.js";
+import type { ContainerRuntimeOptionsInternal } from "./containerRuntime.js";
+
+/**
+ * Subset of the {@link ContainerRuntimeOptionsInternal} properties which
+ * affect {@link IDocumentSchemaFeatures}.
+ *
+ * @remarks
+ * When a new option is added to {@link ContainerRuntimeOptionsInternal}, we
+ * must consider if it changes the DocumentSchema. If so, then a corresponding
+ * entry must be added to {@link runtimeOptionsAffectingDocSchemaConfigMap}
+ * below. If not, then it must be omitted from this type.
+ *
+ * Note: `Omit` is used instead of `Pick` to ensure that all new options are
+ * included in this type by default. If any new properties are added to
+ * {@link ContainerRuntimeOptionsInternal}, they will be included in this
+ * type unless explicitly omitted. This will prevent us from forgetting to
+ * account for any new properties in the future.
+ */
+export type RuntimeOptionsAffectingDocSchema = Omit<
+	ContainerRuntimeOptionsInternal,
+	| "chunkSizeInBytes"
+	| "maxBatchSizeInBytes"
+	| "loadSequenceNumberVerification"
+	| "summaryOptions"
+>;
+
+/**
+ * Mapping of RuntimeOptionsAffectingDocSchema to their compatibility related configs.
+ *
+ * Each key in this map corresponds to a property in RuntimeOptionsAffectingDocSchema. The value is an object that maps MinimumVersionForCollab
+ * to the appropriate default value for that property to supporting that MinimumVersionForCollab. If clients running MinimumVersionForCollab X are able to understand
+ * the format changes introduced by the property, then the default value for that MinimumVersionForCollab will enable the feature associated with the property.
+ * Otherwise, the feature will be disabled.
+ *
+ * For example if the minVersionForCollab is a 1.x version (i.e. "1.5.0"), then the default value for `enableGroupedBatching` will be false since 1.x
+ * clients do not understand the document format when batching is enabled. If the minVersionForCollab is a 2.x client (i.e. "2.0.0" or later), then the
+ * default value for `enableGroupedBatching` will be true because clients running 2.0 or later will be able to understand the format changes associated
+ * with the batching feature.
+ */
+const runtimeOptionsAffectingDocSchemaConfigMap = {
+	enableGroupedBatching: {
+		"1.0.0": false,
+		"2.0.0-defaults": true,
+	},
+	compressionOptions: {
+		"1.0.0": disabledCompressionConfig,
+		"2.0.0-defaults": enabledCompressionConfig,
+	},
+	enableRuntimeIdCompressor: {
+		// For IdCompressorMode, `undefined` represents a logical state (off).
+		// However, to satisfy the Required<> constraint while
+		// `exactOptionalPropertyTypes` is `false` (TODO: AB#8215), we need
+		// to have it defined, so we trick the type checker here.
+		"1.0.0": undefined,
+		// We do not yet want to enable idCompressor by default since it will
+		// increase bundle sizes, and not all customers will benefit from it.
+		// Therefore, we will require customers to explicitly enable it. We
+		// are keeping it as a DocSchema affecting option for now as this may
+		// change in the future.
+	},
+	explicitSchemaControl: {
+		"1.0.0": false,
+		// This option's intention is to prevent 1.x clients from joining sessions
+		// when enabled. This is set to true when the minVersionForCollab is set
+		// to >=2.0.0 (explicitly). This is different than other 2.0 defaults
+		// because it was not enabled by default prior to the implementation of
+		// `minVersionForCollab`.
+		// `defaultMinVersionForCollab` is set to "2.0.0-defaults" which "2.0.0"
+		// does not satisfy to avoiding enabling this option by default as of
+		// `minVersionForCollab` introduction, which could be unexpected.
+		// Only enable as a default when `minVersionForCollab` is specified at
+		// 2.0.0+.
+		"2.0.0": true,
+	},
+	flushMode: {
+		// Note: 1.x clients are compatible with TurnBased flushing, but here we elect to remain on Immediate flush mode
+		// as a work-around for inability to send batches larger than 1Mb. Immediate flushing keeps batches smaller as
+		// fewer messages will be included per flush.
+		"1.0.0": FlushMode.Immediate,
+		"2.0.0-defaults": FlushMode.TurnBased,
+	},
+	gcOptions: {
+		"1.0.0": {},
+		// Although sweep is supported in 2.x, it is disabled by default until minVersionForCollab>=3.0.0 to be extra safe.
+		"3.0.0": { enableGCSweep: true },
+	},
+	createBlobPayloadPending: {
+		// This feature is new and disabled by default. In the future we will enable it by default, but we have not
+		// closed on the version where that will happen yet.  Probably a .10 release since blob functionality is not
+		// exposed on the `@public` API surface.
+		"1.0.0": undefined,
+	},
+} as const satisfies ConfigMap<RuntimeOptionsAffectingDocSchema>;
+
+const runtimeOptionsAffectingDocSchemaConfigValidationMap = {
+	enableGroupedBatching: configValueToMinVersionForCollab([
+		[false, "1.0.0"],
+		[true, "2.0.0-defaults"],
+	]),
+	compressionOptions: configValueToMinVersionForCollab([
+		[{ ...disabledCompressionConfig }, "1.0.0"],
+		[{ ...enabledCompressionConfig }, "2.0.0-defaults"],
+	]),
+	enableRuntimeIdCompressor: configValueToMinVersionForCollab([
+		[undefined, "1.0.0"],
+		["on", "2.0.0-defaults"],
+		["delayed", "2.0.0-defaults"],
+	]),
+	explicitSchemaControl: configValueToMinVersionForCollab([
+		[false, "1.0.0"],
+		[true, "2.0.0-defaults"],
+	]),
+	flushMode: configValueToMinVersionForCollab([
+		[FlushMode.Immediate, "1.0.0"],
+		[FlushMode.TurnBased, "2.0.0-defaults"],
+	]),
+	gcOptions: configValueToMinVersionForCollab([
+		[{ enableGCSweep: undefined }, "1.0.0"],
+		[{ enableGCSweep: true }, "2.0.0-defaults"],
+	]),
+	createBlobPayloadPending: configValueToMinVersionForCollab([
+		[undefined, "1.0.0"],
+		[true, "2.40.0"],
+	]),
+} as const satisfies ConfigValidationMap<RuntimeOptionsAffectingDocSchema>;
+
+/**
+ * Returns the default RuntimeOptionsAffectingDocSchema configuration for a given minVersionForCollab.
+ */
+export function getMinVersionForCollabDefaults(
+	minVersionForCollab: MinimumVersionForCollab,
+): RuntimeOptionsAffectingDocSchema {
+	return getConfigsForMinVersionForCollab(
+		minVersionForCollab,
+		runtimeOptionsAffectingDocSchemaConfigMap,
+		// This is a bad cast away from Partial that getConfigsForCompatMode provides.
+		// ConfigMap should be restructured to provide RuntimeOptionsAffectingDocSchema guarantee.
+	) as RuntimeOptionsAffectingDocSchema;
+}
+
+/**
+ * Validates if the runtime options passed in from the user are compatible with the minVersionForCollab.
+ * For example, if a user sets the `enableGroupedBatching` option to true, but the minVersionForCollab
+ * is set to "1.0.0", then we should throw a UsageError since 1.x clients do not support batching.
+ * */
+export function validateRuntimeOptions(
+	minVersionForCollab: MinimumVersionForCollab,
+	runtimeOptions: Partial<ContainerRuntimeOptionsInternal>,
+): void {
+	getValidationForRuntimeOptions<RuntimeOptionsAffectingDocSchema>(
+		minVersionForCollab,
+		runtimeOptions as Partial<RuntimeOptionsAffectingDocSchema>,
+		runtimeOptionsAffectingDocSchemaConfigValidationMap,
+	);
+}