@fluidframework/container-runtime 2.70.0-361248 → 2.70.0

package/src/containerRuntime.ts

@@ -23,6 +23,7 @@ import type {
 	IDeltaManagerFull,
 	ILoader,
 	IContainerStorageService,
+	ConnectionStatus,
 } from "@fluidframework/container-definitions/internal";
 import {
 	ConnectionState,
@@ -120,10 +121,8 @@ import type {
 	IInboundSignalMessage,
 	IRuntimeMessagesContent,
 	ISummarizerNodeWithGC,
-	// eslint-disable-next-line import/no-deprecated
-	StageControlsExperimental,
-	// eslint-disable-next-line import/no-deprecated
-	IContainerRuntimeBaseExperimental,
+	StageControlsInternal,
+	IContainerRuntimeBaseInternal,
 	IFluidParentContext,
 	MinimumVersionForCollab,
 } from "@fluidframework/runtime-definitions/internal";
@@ -817,8 +816,7 @@ export class ContainerRuntime
 	extends TypedEventEmitter<IContainerRuntimeEvents>
 	implements
 		IContainerRuntimeInternal,
-		// eslint-disable-next-line import/no-deprecated
-		IContainerRuntimeBaseExperimental,
+		IContainerRuntimeBaseInternal,
 		// eslint-disable-next-line import/no-deprecated
 		IContainerRuntimeWithResolveHandle_Deprecated,
 		IRuntime,
@@ -1215,6 +1213,8 @@ export class ContainerRuntime
 			recentBatchInfo,
 		);
 
+		runtime.sharePendingBlobs();
+
 		// Initialize the base state of the runtime before it's returned.
 		await runtime.initializeBaseState(context.loader);
 
@@ -1568,6 +1568,7 @@ export class ContainerRuntime
 			deltaManager,
 			quorum,
 			audience,
+			signalAudience,
 			pendingLocalState,
 			supportedFeatures,
 			snapshotWithContents,
@@ -1581,13 +1582,6 @@ export class ContainerRuntime
 
 		this.isSnapshotInstanceOfISnapshot = snapshotWithContents !== undefined;
 
-		// Validate that the Loader is compatible with this Runtime.
-		const maybeLoaderCompatDetailsForRuntime = context as FluidObject<ILayerCompatDetails>;
-		validateLoaderCompatibility(
-			maybeLoaderCompatDetailsForRuntime.ILayerCompatDetails,
-			this.disposeFn,
-		);
-
 		this.mc = createChildMonitoringContext({
 			logger: this.baseLogger,
 			namespace: "ContainerRuntime",
@@ -1598,6 +1592,14 @@ export class ContainerRuntime
 			},
 		});
 
+		// Validate that the Loader is compatible with this Runtime.
+		const maybeLoaderCompatDetailsForRuntime = context as FluidObject<ILayerCompatDetails>;
+		validateLoaderCompatibility(
+			maybeLoaderCompatDetailsForRuntime.ILayerCompatDetails,
+			this.disposeFn,
+			this.mc.logger,
+		);
+
 		// If we support multiple algorithms in the future, then we would need to manage it here carefully.
 		// We can use runtimeOptions.compressionOptions.compressionAlgorithm, but only if it's in the schema list!
 		// If it's not in the list, then we will need to either use no compression, or fallback to some other (supported by format)
@@ -1718,10 +1720,11 @@ export class ContainerRuntime
 		this.messageAtLastSummary = lastMessageFromMetadata(metadata);
 
 		// Note that we only need to pull the *initial* connected state from the context.
-		// Later updates come through calls to setConnectionState.
+		// Later updates come through calls to setConnectionState/Status.
 		this.canSendOps = connected;
 		this.canSendSignals = this.getConnectionState
-			? this.getConnectionState() === ConnectionState.Connected
+			? this.getConnectionState() === ConnectionState.Connected ||
+				this.getConnectionState() === ConnectionState.CatchingUp
 			: undefined;
 
 		this.mc.logger.sendTelemetryEvent({
@@ -2037,6 +2040,8 @@ export class ContainerRuntime
 			});
 		}
 
+		this.signalAudience = signalAudience;
+
 		const closeSummarizerDelayOverride = this.mc.config.getNumber(
 			"Fluid.ContainerRuntime.Test.CloseSummarizerDelayOverrideMs",
 		);
@@ -2809,6 +2814,59 @@ export class ContainerRuntime
 		this.channelCollection.notifyReadOnlyState(readonly);
 
 	public setConnectionState(canSendOps: boolean, clientId?: string): void {
+		this.setConnectionStateToConnectedOrDisconnected(canSendOps, clientId);
+	}
+
+	public setConnectionStatus(status: ConnectionStatus): void {
+		switch (status.connectionState) {
+			case ConnectionState.Connected: {
+				this.setConnectionStateToConnectedOrDisconnected(
+					status.canSendOps,
+					status.clientConnectionId,
+				);
+
+				break;
+			}
+			case ConnectionState.Disconnected: {
+				this.setConnectionStateToConnectedOrDisconnected(
+					status.canSendOps,
+					status.priorConnectedClientConnectionId,
+				);
+
+				break;
+			}
+			case ConnectionState.CatchingUp: {
+				assert(
+					this.getConnectionState !== undefined &&
+						this.getConnectionState() === ConnectionState.CatchingUp,
+					0xc8d /* connection state mismatch between getConnectionState and setConnectionStatus notification */,
+				);
+
+				// Note: Historically when only `setConnectionState` of `IRuntime`
+				// was supported, it was possible to be in `CatchingUp` state and
+				// call through to `setConnectionStateCore` when there is a readonly
+				// change - see `Container`'s `"deltaManager.on("readonly"`. There
+				// would not be a transition of `canSendOps` in that case, but
+				// `channelCollection` and `garbageCollector` would receive early
+				// `setConnectionState` call AND `this` would `emit` "disconnected"
+				// event.
+
+				this.emitServiceConnectionEvents(
+					/* canSendOpsChanged */ this.canSendOps,
+					/* canSendOps */ false,
+					status.pendingClientConnectionId,
+				);
+
+				break;
+			}
+			// No default
+		}
+	}
+
+	private setConnectionStateToConnectedOrDisconnected(
+		canSendOps: boolean,
+		clientId: string | undefined,
+	): void {
 		// Validate we have consistent state
 		const currentClientId = this._audience.getSelf()?.clientId;
 		assert(clientId === currentClientId, 0x977 /* input clientId does not match Audience */);
@@ -2893,7 +2951,7 @@ export class ContainerRuntime
 	 * Emits service connection events based on connection state changes.
 	 *
 	 * @remarks
-	 * "connectedToService" is emitted when container connection state transitions to 'Connected' regardless of connection mode.
+	 * "connectedToService" is emitted when container connection state transitions to 'CatchingUp' or 'Connected' regardless of connection mode.
 	 * "disconnectedFromService" excludes false "disconnected" events that happen when readonly client transitions to 'Connected'.
 	 */
 	private emitServiceConnectionEvents(
@@ -2905,21 +2963,25 @@ export class ContainerRuntime
 			return;
 		}
 
-		const canSendSignals = this.getConnectionState() === ConnectionState.Connected;
+		const connectionState = this.getConnectionState();
+		const canSendSignals =
+			connectionState === ConnectionState.Connected ||
+			connectionState === ConnectionState.CatchingUp;
 		const canSendSignalsChanged = this.canSendSignals !== canSendSignals;
 		this.canSendSignals = canSendSignals;
 		if (canSendSignalsChanged) {
-			// If canSendSignals changed, we either transitioned from Connected to Disconnected or CatchingUp to Connected
+			// If canSendSignals changed, we either transitioned from CatchingUp or
+			// Connected to Disconnected or EstablishingConnection to CatchingUp.
 			if (canSendSignals) {
-				// Emit for CatchingUp to Connected transition
+				// Emit for EstablishingConnection to CatchingUp or Connected transition
 				this.emit("connectedToService", clientId, canSendOps);
 			} else {
-				// Emit for Connected to Disconnected transition
+				// Emit for CatchingUp or Connected to Disconnected transition
 				this.emit("disconnectedFromService");
 			}
 		} else if (canSendOpsChanged) {
-			// If canSendSignals did not change but canSendOps did, then connection type has changed.
-			this.emit("connectionTypeChanged", canSendOps);
+			// If canSendSignals did not change but canSendOps did, then operations possible has changed.
+			this.emit("operabilityChanged", canSendOps);
 		}
 	}
 
@@ -3452,8 +3514,7 @@ export class ContainerRuntime
 	 */
 	public orderSequentially<T>(callback: () => T): T {
 		let checkpoint: IBatchCheckpoint | undefined;
-		// eslint-disable-next-line import/no-deprecated
-		let stageControls: StageControlsExperimental | undefined;
+		let stageControls: StageControlsInternal | undefined;
 		if (this.mc.config.getBoolean("Fluid.ContainerRuntime.EnableRollback") === true) {
 			if (!this.batchRunner.running && !this.inStagingMode) {
 				stageControls = this.enterStagingMode();
@@ -3517,8 +3578,7 @@ export class ContainerRuntime
 		return result;
 	}
 
-	// eslint-disable-next-line import/no-deprecated
-	private stageControls: StageControlsExperimental | undefined;
+	private stageControls: StageControlsInternal | undefined;
 
 	/**
 	 * If true, the ContainerRuntime is not submitting any new ops to the ordering service.
@@ -3533,10 +3593,9 @@ export class ContainerRuntime
 	 * Enter Staging Mode, such that ops submitted to the ContainerRuntime will not be sent to the ordering service.
 	 * To exit Staging Mode, call either discardChanges or commitChanges on the Stage Controls returned from this method.
 	 *
-	 * @returns StageControlsExperimental - Controls for exiting Staging Mode.
+	 * @returns Controls for exiting Staging Mode.
 	 */
-	// eslint-disable-next-line import/no-deprecated
-	public enterStagingMode = (): StageControlsExperimental => {
+	public enterStagingMode = (): StageControlsInternal => {
 		if (this.stageControls !== undefined) {
 			throw new UsageError("Already in staging mode");
 		}
@@ -3569,8 +3628,7 @@ export class ContainerRuntime
 			}
 		};
 
-		// eslint-disable-next-line import/no-deprecated
-		const stageControls: StageControlsExperimental = {
+		const stageControls: StageControlsInternal = {
 			discardChanges: () =>
 				exitStagingMode(() => {
 					// Pop all staged batches from the PSM and roll them back in LIFO order
@@ -3677,6 +3735,14 @@ export class ContainerRuntime
 		return this._audience;
 	}
 
+	/**
+	 * When defined, this {@link @fluidframework/container-definitions#IAudience}
+	 * maintains member list using signals only.
+	 * Thus "write" members may be known earlier than quorum and avoid noise from
+	 * un-summarized quorum history.
+	 */
+	private readonly signalAudience?: IAudience;
+
 	/**
 	 * Returns true of container is dirty, i.e. there are some pending local changes that
 	 * either were not sent out to delta stream or were not yet acknowledged.
@@ -4548,7 +4614,6 @@ export class ContainerRuntime
 		contents: any,
 		localOpMetadata: unknown = undefined,
 	): void {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 		this.submit({ type, contents }, localOpMetadata);
 	}
 
@@ -5133,6 +5198,43 @@ export class ContainerRuntime
 		);
 	}
 
+	/**
+	 * ContainerRuntime knows about additional restrictions on when blob sharing can be resumed as compared
+	 * to BlobManager. In particular, it wants to avoid sharing blobs while in readonly state, and it also
+	 * wants to avoid sharing blobs before connection completes (otherwise it may cause the sharing to happen
+	 * before processing shared ops).
+	 *
+	 * This method can be called safely before those conditions are met. In the background, it will wait until
+	 * it is safe before initiating sharing. It will close the container on any error.
+	 */
+	public sharePendingBlobs = (): void => {
+		new Promise<void>((resolve) => {
+			// eslint-disable-next-line unicorn/consistent-function-scoping
+			const canStartSharing = (): boolean =>
+				this.connected && this.deltaManager.readOnlyInfo.readonly !== true;
+
+			if (canStartSharing()) {
+				resolve();
+				return;
+			}
+
+			const checkCanShare = (readonly: boolean): void => {
+				if (canStartSharing()) {
+					this.deltaManager.off("readonly", checkCanShare);
+					this.off("connected", checkCanShare);
+					resolve();
+				}
+			};
+			this.deltaManager.on("readonly", checkCanShare);
+			this.on("connected", checkCanShare);
+		})
+			.then(this.blobManager.sharePendingBlobs)
+			// It may not be necessary to close the container on failures - this should just mean there's
+			// a handle in the container that is stuck pending, which is a scenario that customers need to
+			// handle anyway. Starting with this more aggressive/restrictive behavior to be cautious.
+			.catch(this.closeFn);
+	};
+
 	public summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults {
 		if (this._summarizer !== undefined) {
 			return this._summarizer.summarizeOnDemand(options);
@@ -5169,8 +5271,8 @@ export class ContainerRuntime
 				eventEmitter.emit("joined", { clientId, canWrite });
 			});
 			this.on("disconnectedFromService", () => eventEmitter.emit("disconnected"));
-			this.on("connectionTypeChanged", (canWrite: boolean) =>
-				eventEmitter.emit("connectionTypeChanged", canWrite),
+			this.on("operabilityChanged", (canWrite: boolean) =>
+				eventEmitter.emit("operabilityChanged", canWrite),
 			);
 		} else {
 			this.on("connected", (clientId: string) => {
@@ -5185,7 +5287,11 @@ export class ContainerRuntime
 		const getConnectionState = this.getConnectionState;
 		if (getConnectionState) {
 			const connectionState = getConnectionState();
-			if (connectionState === ConnectionState.Connected) {
+			if (
+				connectionState === ConnectionState.Connected ||
+				connectionState === ConnectionState.CatchingUp
+			) {
+				// Note: when CatchingUp, canSendOps will always be false.
 				return this.canSendOps ? "joinedForWriting" : "joinedForReading";
 			}
 		} else if (this.canSendOps) {
@@ -5211,9 +5317,10 @@ export class ContainerRuntime
 	): T {
 		let entry = this.extensions.get(id);
 		if (entry === undefined) {
+			const audience = this.signalAudience;
 			const runtime = {
 				getJoinedStatus: this.getJoinedStatus.bind(this),
-				getClientId: () => this.clientId,
+				getClientId: audience ? () => audience.getSelf()?.clientId : () => this.clientId,
 				events: this.lazyEventsForExtensions.value,
 				logger: this.baseLogger,
 				submitAddressedSignal: (
@@ -5223,7 +5330,7 @@ export class ContainerRuntime
 					this.submitExtensionSignal(id, addressChain, message);
 				},
 				getQuorum: this.getQuorum.bind(this),
-				getAudience: this.getAudience.bind(this),
+				getAudience: audience ? () => audience : this.getAudience.bind(this),
 				supportedFeatures: this.ILayerCompatDetails.supportedFeatures,
 			} satisfies ExtensionHost<TRuntimeProperties>;
 			entry = new factory(runtime, ...useContext);

package/src/dataStore.ts

@@ -7,12 +7,11 @@ import { AttachState } from "@fluidframework/container-definitions";
 import type { FluidObject } from "@fluidframework/core-interfaces";
 import type { IFluidHandleInternal } from "@fluidframework/core-interfaces/internal";
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import type {
-	AliasResult,
-	IDataStore,
-	IFluidDataStoreChannel,
-	// eslint-disable-next-line import/no-deprecated
-	IContainerRuntimeBaseExperimental,
+import {
+	type AliasResult,
+	type IDataStore,
+	type IFluidDataStoreChannel,
+	asLegacyAlpha,
 } from "@fluidframework/runtime-definitions/internal";
 import {
 	type ITelemetryLoggerExt,
@@ -80,9 +79,7 @@ class DataStore implements IDataStore {
 		if (alias.includes("/")) {
 			throw new UsageError(`The alias cannot contain slashes: '${alias}'`);
 		}
-		// eslint-disable-next-line import/no-deprecated
-		const runtime = this.parentContext.containerRuntime as IContainerRuntimeBaseExperimental;
-		if (runtime.inStagingMode === true) {
+		if (asLegacyAlpha(this.parentContext.containerRuntime).inStagingMode === true) {
 			throw new UsageError("Cannot set aliases while in staging mode");
 		}
 

package/src/dataStoreContext.ts

@@ -1004,6 +1004,7 @@ export abstract class FluidDataStoreContext
 		validateDatastoreCompatibility(
 			maybeDataStoreCompatDetails.ILayerCompatDetails,
 			this.dispose.bind(this),
+			this.mc.logger,
 		);
 
 		// And now mark the runtime active

package/src/opLifecycle/outbox.ts

@@ -365,6 +365,16 @@ export class Outbox {
 	 * @param resubmitInfo - Key information when flushing a resubmitted batch. Undefined means this is not resubmit.
 	 */
 	public flush(resubmitInfo?: BatchResubmitInfo): void {
+		// We have nothing to flush if all batchManagers are empty, and we we're not needing to resubmit an empty batch placeholder
+		if (
+			this.idAllocationBatch.empty &&
+			this.blobAttachBatch.empty &&
+			this.mainBatch.empty &&
+			resubmitInfo?.batchId === undefined
+		) {
+			return;
+		}
+
 		assert(
 			!this.isContextReentrant(),
 			0xb7b /* Flushing must not happen while incoming changes are being processed */,

package/src/packageVersion.ts

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

package/src/runtimeLayerCompatState.ts

@@ -3,17 +3,19 @@
  * Licensed under the MIT License.
  */
 
-import {
-	checkLayerCompatibility,
-	type ILayerCompatDetails,
-	type ILayerCompatSupportRequirements,
+import type {
+	ILayerCompatDetails,
+	ILayerCompatSupportRequirements,
 } from "@fluid-internal/client-utils";
 import type { ICriticalContainerError } from "@fluidframework/container-definitions";
 import {
 	encodeHandlesInContainerRuntime,
 	notifiesReadOnlyState,
 } from "@fluidframework/runtime-definitions/internal";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import {
+	validateLayerCompatibility,
+	type ITelemetryLoggerExt,
+} from "@fluidframework/telemetry-utils/internal";
 
 import { pkgVersion } from "./packageVersion.js";
 
@@ -95,26 +97,17 @@ export const dataStoreSupportRequirementsForRuntime: ILayerCompatSupportRequirem
 export function validateLoaderCompatibility(
 	maybeLoaderCompatDetailsForRuntime: ILayerCompatDetails | undefined,
 	disposeFn: (error?: ICriticalContainerError) => void,
+	logger: ITelemetryLoggerExt,
 ): void {
-	const layerCheckResult = checkLayerCompatibility(
+	validateLayerCompatibility(
+		"runtime",
+		"loader",
+		runtimeCompatDetailsForLoader,
 		loaderSupportRequirementsForRuntime,
 		maybeLoaderCompatDetailsForRuntime,
+		disposeFn,
+		logger,
 	);
-	if (!layerCheckResult.isCompatible) {
-		const error = new UsageError("Runtime is not compatible with Loader", {
-			errorDetails: JSON.stringify({
-				runtimeVersion: runtimeCoreCompatDetails.pkgVersion,
-				loaderVersion: maybeLoaderCompatDetailsForRuntime?.pkgVersion,
-				runtimeGeneration: runtimeCoreCompatDetails.generation,
-				loaderGeneration: maybeLoaderCompatDetailsForRuntime?.generation,
-				minSupportedGeneration: loaderSupportRequirementsForRuntime.minSupportedGeneration,
-				isGenerationCompatible: layerCheckResult.isGenerationCompatible,
-				unsupportedFeatures: layerCheckResult.unsupportedFeatures,
-			}),
-		});
-		disposeFn(error);
-		throw error;
-	}
 }
 
 /**
@@ -122,26 +115,17 @@ export function validateLoaderCompatibility(
  * @internal
  */
 export function validateDatastoreCompatibility(
-	maybeDataStoreCompatDetails: ILayerCompatDetails | undefined,
+	maybeDataStoreCompatDetailsForRuntime: ILayerCompatDetails | undefined,
 	disposeFn: () => void,
+	logger: ITelemetryLoggerExt,
 ): void {
-	const layerCheckResult = checkLayerCompatibility(
+	validateLayerCompatibility(
+		"runtime",
+		"dataStore",
+		runtimeCompatDetailsForDataStore,
 		dataStoreSupportRequirementsForRuntime,
-		maybeDataStoreCompatDetails,
+		maybeDataStoreCompatDetailsForRuntime,
+		disposeFn,
+		logger,
 	);
-	if (!layerCheckResult.isCompatible) {
-		const error = new UsageError("Runtime is not compatible with DataStore", {
-			errorDetails: JSON.stringify({
-				runtimeVersion: runtimeCoreCompatDetails.pkgVersion,
-				dataStoreVersion: maybeDataStoreCompatDetails?.pkgVersion,
-				runtimeGeneration: runtimeCoreCompatDetails.generation,
-				dataStoreGeneration: maybeDataStoreCompatDetails?.generation,
-				minSupportedGeneration: dataStoreSupportRequirementsForRuntime.minSupportedGeneration,
-				isGenerationCompatible: layerCheckResult.isGenerationCompatible,
-				unsupportedFeatures: layerCheckResult.unsupportedFeatures,
-			}),
-		});
-		disposeFn();
-		throw error;
-	}
 }

package/src/storageServiceWithAttachBlobs.ts

@@ -3,20 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type {
-	FetchSource,
-	ICreateBlobResponse,
-	IDocumentStorageServicePolicies,
-	ISnapshot,
-	ISnapshotFetchOptions,
-	ISnapshotTree,
-	ISummaryContext,
-	ISummaryHandle,
-	ISummaryTree,
-	IVersion,
-} from "@fluidframework/driver-definitions/internal";
 import type { IRuntimeStorageService } from "@fluidframework/runtime-definitions/internal";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 /**
  * IRuntimeStorageService proxy which intercepts requests if they can be satisfied by the blobs received in the
@@ -28,14 +15,6 @@ export class StorageServiceWithAttachBlobs implements IRuntimeStorageService {
 		private readonly attachBlobs: Map<string, ArrayBufferLike>,
 	) {}
 
-	/**
-	 * {@link IRuntimeStorageService.policies}.
-	 * @deprecated This will be removed in a future release. The DataStore layer does not need this.
-	 */
-	public get policies(): IDocumentStorageServicePolicies | undefined {
-		return this.internalStorageService.policies;
-	}
-
 	public async readBlob(id: string): Promise<ArrayBufferLike> {
 		const blob = this.attachBlobs.get(id);
 		if (blob !== undefined) {
@@ -46,75 +25,4 @@ export class StorageServiceWithAttachBlobs implements IRuntimeStorageService {
 		// IRuntimeStorageService to cache appropriately, no need to double-cache.
 		return this.internalStorageService.readBlob(id);
 	}
-
-	/**
-	 * {@link IRuntimeStorageService.getSnapshotTree}.
-	 * @deprecated This will be removed in a future release. The DataStore layer does not need this.
-	 */
-	public async getSnapshotTree(
-		version?: IVersion,
-		scenarioName?: string,
-		// eslint-disable-next-line @rushstack/no-new-null
-	): Promise<ISnapshotTree | null> {
-		return this.internalStorageService.getSnapshotTree(version, scenarioName);
-	}
-
-	/**
-	 * {@link IRuntimeStorageService.getSnapshot}.
-	 * @deprecated This will be removed in a future release. The DataStore layer does not need this.
-	 */
-	public async getSnapshot(snapshotFetchOptions?: ISnapshotFetchOptions): Promise<ISnapshot> {
-		if (this.internalStorageService.getSnapshot !== undefined) {
-			return this.internalStorageService.getSnapshot(snapshotFetchOptions);
-		}
-		throw new UsageError(
-			"getSnapshot api should exist on internal storage in documentStorageServiceProxy class",
-		);
-	}
-
-	/**
-	 * {@link IRuntimeStorageService.getVersions}.
-	 * @deprecated This will be removed in a future release. The DataStore layer does not need this.
-	 */
-	public async getVersions(
-		// eslint-disable-next-line @rushstack/no-new-null
-		versionId: string | null,
-		count: number,
-		scenarioName?: string,
-		fetchSource?: FetchSource,
-	): Promise<IVersion[]> {
-		return this.internalStorageService.getVersions(
-			versionId,
-			count,
-			scenarioName,
-			fetchSource,
-		);
-	}
-
-	/**
-	 * {@link IRuntimeStorageService.uploadSummaryWithContext}.
-	 * @deprecated This will be removed in a future release. The DataStore layer does not need this.
-	 */
-	public async uploadSummaryWithContext(
-		summary: ISummaryTree,
-		context: ISummaryContext,
-	): Promise<string> {
-		return this.internalStorageService.uploadSummaryWithContext(summary, context);
-	}
-
-	/**
-	 * {@link IRuntimeStorageService.createBlob}.
-	 * @deprecated This will be removed in a future release. The DataStore layer does not need this.
-	 */
-	public async createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse> {
-		return this.internalStorageService.createBlob(file);
-	}
-
-	/**
-	 * {@link IRuntimeStorageService.downloadSummary}.
-	 * @deprecated This will be removed in a future release. The DataStore layer does not need this.
-	 */
-	public async downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree> {
-		return this.internalStorageService.downloadSummary(handle);
-	}
 }