@fluidframework/container-loader 2.0.0-dev-rc.1.0.0.232845 → 2.0.0-dev-rc.2.0.0.245554

package/src/connectionManager.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { IDisposable, ITelemetryProperties, LogLevel } from "@fluidframework/core-interfaces";
+import { IDisposable, ITelemetryBaseProperties, LogLevel } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils";
 import { performance, TypedEventEmitter } from "@fluid-internal/client-utils";
 import {
@@ -57,10 +57,10 @@ import {
 	IConnectionManagerFactoryArgs,
 	IConnectionDetailsInternal,
 	IConnectionStateChangeReason,
-} from "./contracts";
-import { DeltaQueue } from "./deltaQueue";
-import { SignalType } from "./protocol";
-import { isDeltaStreamConnectionForbiddenError } from "./utils";
+} from "./contracts.js";
+import { DeltaQueue } from "./deltaQueue.js";
+import { SignalType } from "./protocol.js";
+import { isDeltaStreamConnectionForbiddenError } from "./utils.js";
 
 // We double this value in first try in when we calculate time to wait for in "calculateMaxWaitTime" function.
 const InitialReconnectDelayInMs = 500;
@@ -229,7 +229,7 @@ export class ConnectionManager implements IConnectionManager {
 
 	private _connectionVerboseProps: Record<string, string | number> = {};
 
-	private _connectionProps: ITelemetryProperties = {};
+	private _connectionProps: ITelemetryBaseProperties = {};
 
 	private _disposed = false;
 
@@ -290,7 +290,7 @@ export class ConnectionManager implements IConnectionManager {
 	 * Returns set of props that can be logged in telemetry that provide some insights / statistics
 	 * about current or last connection (if there is no connection at the moment)
 	 */
-	public get connectionProps(): ITelemetryProperties {
+	public get connectionProps(): ITelemetryBaseProperties {
 		return this.connection !== undefined
 			? this._connectionProps
 			: {
@@ -654,8 +654,12 @@ export class ConnectionManager implements IConnectionManager {
 				if (retryDelayFromError !== undefined || globalThis.navigator?.onLine !== false) {
 					delayMs = calculateMaxWaitTime(delayMs, origError);
 				}
-				// Raise event in case the delay was there.
-				this.props.reconnectionDelayHandler(delayMs, origError);
+
+				// Raise event in case the delay was there from the error.
+				if (retryDelayFromError !== undefined) {
+					this.props.reconnectionDelayHandler(delayMs, origError);
+				}
+
 				await new Promise<void>((resolve) => {
 					setTimeout(resolve, delayMs);
 				});

package/src/connectionState.ts

@@ -4,6 +4,7 @@
  */
 
 /**
+ * The state of the Container's connection to the service.
  * @public
  */
 export enum ConnectionState {

package/src/connectionStateHandler.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryProperties, TelemetryEventCategory } from "@fluidframework/core-interfaces";
+import { ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
 import { assert, Timer } from "@fluidframework/core-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
 import { ISequencedClient, IClient } from "@fluidframework/protocol-definitions";
@@ -11,12 +11,13 @@ import {
 	ITelemetryLoggerExt,
 	PerformanceEvent,
 	loggerToMonitoringContext,
+	type TelemetryEventCategory,
 } from "@fluidframework/telemetry-utils";
 import { IAnyDriverError } from "@fluidframework/driver-definitions";
-import { CatchUpMonitor, ICatchUpMonitor } from "./catchUpMonitor";
-import { ConnectionState } from "./connectionState";
-import { IConnectionDetailsInternal, IConnectionStateChangeReason } from "./contracts";
-import { IProtocolHandler } from "./protocol";
+import { CatchUpMonitor, ICatchUpMonitor } from "./catchUpMonitor.js";
+import { ConnectionState } from "./connectionState.js";
+import { IConnectionDetailsInternal, IConnectionStateChangeReason } from "./contracts.js";
+import { IProtocolHandler } from "./protocol.js";
 
 // Based on recent data, it looks like majority of cases where we get stuck are due to really slow or
 // timing out ops fetches. So attempt recovery infrequently. Also fetch uses 30 second timeout, so
@@ -43,7 +44,7 @@ export interface IConnectionStateHandlerInputs {
 	logConnectionIssue: (
 		eventName: string,
 		category: TelemetryEventCategory,
-		details?: ITelemetryProperties,
+		details?: ITelemetryBaseProperties,
 	) => void;
 	/** Callback to note that an old local client ID is still present in the Quorum that should have left and should now be considered invalid */
 	clientShouldHaveLeft: (clientId: string) => void;
@@ -188,7 +189,7 @@ class ConnectionStateHandlerPassThrough
 	public logConnectionIssue(
 		eventName: string,
 		category: TelemetryEventCategory,
-		details?: ITelemetryProperties,
+		details?: ITelemetryBaseProperties,
 	) {
 		return this.inputs.logConnectionIssue(eventName, category, details);
 	}

package/src/container.ts

@@ -4,12 +4,11 @@
  */
 
 import { v4 as uuid } from "uuid";
-import { assert, unreachableCase } from "@fluidframework/core-utils";
+import { assert, unreachableCase, isPromiseLike } from "@fluidframework/core-utils";
 import { TypedEventEmitter, performance } from "@fluid-internal/client-utils";
 import {
 	IEvent,
-	ITelemetryProperties,
-	TelemetryEventCategory,
+	ITelemetryBaseProperties,
 	FluidObject,
 	LogLevel,
 	IRequest,
@@ -89,26 +88,23 @@ import {
 	GenericError,
 	UsageError,
 	IFluidErrorBase,
+	type TelemetryEventCategory,
 } from "@fluidframework/telemetry-utils";
 import structuredClone from "@ungap/structured-clone";
-import { Audience } from "./audience";
-import { ContainerContext } from "./containerContext";
+import { Audience } from "./audience.js";
+import { ContainerContext } from "./containerContext.js";
 import {
 	ReconnectMode,
 	IConnectionManagerFactoryArgs,
 	getPackageName,
 	IConnectionDetailsInternal,
 	IConnectionStateChangeReason,
-} from "./contracts";
-import { DeltaManager, IConnectionArgs } from "./deltaManager";
-import { IDetachedBlobStorage, ILoaderOptions, RelativeLoader } from "./loader";
-import { pkgVersion } from "./packageVersion";
-import {
-	ContainerStorageAdapter,
-	getBlobContentsFromTree,
-	ISerializableBlobContents,
-} from "./containerStorageAdapter";
-import { IConnectionStateHandler, createConnectionStateHandler } from "./connectionStateHandler";
+} from "./contracts.js";
+import { DeltaManager, IConnectionArgs } from "./deltaManager.js";
+import { IDetachedBlobStorage, ILoaderOptions, RelativeLoader } from "./loader.js";
+import { pkgVersion } from "./packageVersion.js";
+import { ContainerStorageAdapter, ISerializableBlobContents } from "./containerStorageAdapter.js";
+import { IConnectionStateHandler, createConnectionStateHandler } from "./connectionStateHandler.js";
 import {
 	ISnapshotTreeWithBlobContents,
 	combineAppAndProtocolSummary,
@@ -117,18 +113,19 @@ import {
 	combineSnapshotTreeAndSnapshotBlobs,
 	getDetachedContainerStateFromSerializedContainer,
 	runSingle,
-} from "./utils";
-import { initQuorumValuesFromCodeDetails } from "./quorum";
-import { NoopHeuristic } from "./noopHeuristic";
-import { ConnectionManager } from "./connectionManager";
-import { ConnectionState } from "./connectionState";
+} from "./utils.js";
+import { initQuorumValuesFromCodeDetails } from "./quorum.js";
+import { NoopHeuristic } from "./noopHeuristic.js";
+import { ConnectionManager } from "./connectionManager.js";
+import { ConnectionState } from "./connectionState.js";
 import {
 	IProtocolHandler,
 	ProtocolHandler,
 	ProtocolHandlerBuilder,
 	protocolHandlerShouldProcessSignal,
-} from "./protocol";
-import { AttachProcessProps, AttachmentData, runRetriableAttachProcess } from "./attachment";
+} from "./protocol.js";
+import { AttachProcessProps, AttachmentData, runRetriableAttachProcess } from "./attachment.js";
+import { SerializedStateManager } from "./serializedStateManager.js";
 
 const detachedContainerRefSeqNumber = 0;
 
@@ -318,9 +315,7 @@ export async function waitContainerToCatchUp(container: IContainer) {
 	});
 }
 
-const getCodeProposal =
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-	(quorum: IQuorumProposals) => quorum.get("code") ?? quorum.get("code2");
+const getCodeProposal = (quorum: IQuorumProposals) => quorum.get("code") ?? quorum.get("code2");
 
 /**
  * Helper function to report to telemetry cases where operation takes longer than expected (200ms)
@@ -331,7 +326,7 @@ const getCodeProposal =
 export async function ReportIfTooLong(
 	logger: ITelemetryLoggerExt,
 	eventName: string,
-	action: () => Promise<ITelemetryProperties>,
+	action: () => Promise<ITelemetryBaseProperties>,
 ) {
 	const event = PerformanceEvent.start(logger, { eventName });
 	const props = await action();
@@ -346,6 +341,7 @@ export async function ReportIfTooLong(
  * @internal
  */
 export interface IPendingContainerState {
+	attached: true;
 	pendingRuntimeState: unknown;
 	/**
 	 * Snapshot from which container initially loaded.
@@ -372,10 +368,11 @@ export interface IPendingContainerState {
  * @internal
  */
 export interface IPendingDetachedContainerState {
-	attached: boolean;
+	attached: false;
 	baseSnapshot: ISnapshotTree;
 	snapshotBlobs: ISerializableBlobContents;
 	hasAttachmentBlobs: boolean;
+	pendingRuntimeState?: unknown;
 }
 
 const summarizerClientType = "summarizer";
@@ -391,7 +388,6 @@ export class Container
 {
 	/**
 	 * Load an existing container.
-	 * @internal
 	 */
 	public static async load(
 		loadProps: IContainerLoadProps,
@@ -516,7 +512,6 @@ export class Container
 
 	/**
 	 * Used by the RelativeLoader to spawn a new Container for the same document.  Used to create the summarizing client.
-	 * @internal
 	 */
 	public readonly clone: (
 		loadProps: IContainerLoadProps,
@@ -592,8 +587,8 @@ export class Container
 	private readonly connectionTransitionTimes: number[] = [];
 	private _loadedFromVersion: IVersion | undefined;
 	private _dirtyContainer = false;
-	private readonly savedOps: ISequencedDocumentMessage[] = [];
 	private attachmentData: AttachmentData = { state: AttachState.Detached };
+	private readonly serializedStateManager: SerializedStateManager;
 	private readonly _containerId: string;
 
 	private lastVisible: number | undefined;
@@ -676,12 +671,8 @@ export class Container
 		return this._clientId;
 	}
 
-	private get offlineLoadEnabled(): boolean {
-		const enabled =
-			this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad") ??
-			this.options?.enableOfflineLoad === true;
-		// summarizer will not have any pending state we want to save
-		return enabled && this.deltaManager.clientDetails.capabilities.interactive;
+	private get isInteractiveClient(): boolean {
+		return this.deltaManager.clientDetails.capabilities.interactive;
 	}
 
 	/**
@@ -750,9 +741,6 @@ export class Container
 
 	private readonly _lifecycleEvents = new TypedEventEmitter<IContainerLifecycleEvents>();
 
-	/**
-	 * @internal
-	 */
 	constructor(
 		createProps: IContainerCreateProps,
 		loadProps?: Pick<IContainerLoadProps, "pendingLocalState">,
@@ -825,7 +813,7 @@ export class Container
 
 		this.client = Container.setupClient(
 			this._containerId,
-			this.options,
+			options.client,
 			this.clientDetailsOverride,
 		);
 
@@ -902,7 +890,7 @@ export class Container
 				logConnectionIssue: (
 					eventName: string,
 					category: TelemetryEventCategory,
-					details?: ITelemetryProperties,
+					details?: ITelemetryBaseProperties,
 				) => {
 					const mode = this.connectionMode;
 					// We get here when socket does not receive any ops on "write" connection, including
@@ -968,6 +956,17 @@ export class Container
 			forceEnableSummarizeProtocolTree,
 		);
 
+		const offlineLoadEnabled =
+			(this.isInteractiveClient &&
+				this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad")) ??
+			options.enableOfflineLoad === true;
+		this.serializedStateManager = new SerializedStateManager(
+			pendingLocalState,
+			this.subLogger,
+			this.storageAdapter,
+			offlineLoadEnabled,
+		);
+
 		const isDomAvailable =
 			typeof document === "object" &&
 			document !== null &&
@@ -1148,48 +1147,26 @@ export class Container
 	}
 
 	private async getPendingLocalStateCore(props: IGetPendingLocalStateProps) {
-		return PerformanceEvent.timedExecAsync(
-			this.mc.logger,
-			{
-				eventName: "getPendingLocalState",
-				notifyImminentClosure: props.notifyImminentClosure,
-				savedOpsSize: this.savedOps.length,
-				clientId: this.clientId,
-			},
-			async () => {
-				if (!this.offlineLoadEnabled) {
-					throw new UsageError(
-						"Can't get pending local state unless offline load is enabled",
-					);
-				}
-				if (this.closed || this._disposed) {
-					throw new UsageError(
-						"Pending state cannot be retried if the container is closed or disposed",
-					);
-				}
-				assert(
-					this.attachmentData.state === AttachState.Attached,
-					0x0d1 /* "Container should be attached before close" */,
-				);
-				assert(
-					this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid",
-					0x0d2 /* "resolved url should be valid Fluid url" */,
-				);
-				assert(this.attachmentData.snapshot !== undefined, 0x5d5 /* no base data */);
-				const pendingRuntimeState = await this.runtime.getPendingLocalState(props);
-				const pendingState: IPendingContainerState = {
-					pendingRuntimeState,
-					baseSnapshot: this.attachmentData.snapshot.tree,
-					snapshotBlobs: this.attachmentData.snapshot.blobs,
-					savedOps: this.savedOps,
-					url: this.resolvedUrl.url,
-					// no need to save this if there is no pending runtime state
-					clientId: pendingRuntimeState !== undefined ? this.clientId : undefined,
-				};
-
-				return JSON.stringify(pendingState);
-			},
+		if (this.closed || this._disposed) {
+			throw new UsageError(
+				"Pending state cannot be retried if the container is closed or disposed",
+			);
+		}
+		assert(
+			this.attachmentData.state === AttachState.Attached,
+			0x0d1 /* "Container should be attached before close" */,
+		);
+		assert(
+			this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid",
+			0x0d2 /* "resolved url should be valid Fluid url" */,
 		);
+		const pendingState = await this.serializedStateManager.getPendingLocalStateCore(
+			props,
+			this.clientId,
+			this.runtime,
+			this.resolvedUrl,
+		);
+		return pendingState;
 	}
 
 	public get attachState(): AttachState {
@@ -1197,22 +1174,32 @@ export class Container
 	}
 
 	public serialize(): string {
-		assert(
-			this.attachState === AttachState.Detached,
-			0x0d3 /* "Should only be called in detached container" */,
-		);
+		if (this.attachmentData.state === AttachState.Attached || this.closed) {
+			throw new UsageError("Container must not be attached or closed.");
+		}
+
+		const attachingData =
+			this.attachmentData.state === AttachState.Attaching ? this.attachmentData : undefined;
 
-		const appSummary: ISummaryTree = this.runtime.createSummary();
-		const protocolSummary = this.captureProtocolSummary();
-		const combinedSummary = combineAppAndProtocolSummary(appSummary, protocolSummary);
+		const combinedSummary =
+			attachingData?.summary ??
+			combineAppAndProtocolSummary(
+				this.runtime.createSummary(),
+				this.captureProtocolSummary(),
+			);
 
 		const { tree: snapshot, blobs } =
 			getSnapshotTreeAndBlobsFromSerializedContainer(combinedSummary);
 
+		const pendingRuntimeState =
+			attachingData !== undefined ? this.runtime.getPendingLocalState() : undefined;
+		assert(!isPromiseLike(pendingRuntimeState), 0x8e3 /* should not be a promise */);
+
 		const detachedContainerState: IPendingDetachedContainerState = {
 			attached: false,
 			baseSnapshot: snapshot,
 			snapshotBlobs: blobs,
+			pendingRuntimeState,
 			hasAttachmentBlobs: !!this.detachedBlobStorage && this.detachedBlobStorage.size > 0,
 		};
 		return JSON.stringify(detachedContainerState);
@@ -1312,7 +1299,7 @@ export class Container
 
 					let attachP = runRetriableAttachProcess({
 						initialAttachmentData: this.attachmentData,
-						offlineLoadEnabled: this.offlineLoadEnabled,
+						offlineLoadEnabled: this.serializedStateManager.offlineLoadEnabled,
 						detachedBlobStorage: this.detachedBlobStorage,
 						setAttachmentData,
 						createAttachmentSummary,
@@ -1328,8 +1315,7 @@ export class Container
 						});
 					}
 
-					await attachP;
-
+					this.serializedStateManager.setSnapshot(await attachP);
 					if (!this.closed) {
 						this.handleDeltaConnectionArg(
 							{
@@ -1521,11 +1507,6 @@ export class Container
 		return true;
 	}
 
-	private async getVersion(version: string | null): Promise<IVersion | undefined> {
-		const versions = await this.storageAdapter.getVersions(version, 1);
-		return versions[0];
-	}
-
 	private connectToDeltaStream(args: IConnectionArgs) {
 		// All agents need "write" access, including summarizer.
 		if (!this._canReconnect || !this.client.details.capabilities.interactive) {
@@ -1598,33 +1579,11 @@ export class Container
 
 		timings.phase2 = performance.now();
 		// Fetch specified snapshot.
-		const { snapshot, versionId } =
-			pendingLocalState === undefined
-				? await this.fetchSnapshot(specifiedVersion)
-				: { snapshot: pendingLocalState.baseSnapshot, versionId: undefined };
-
-		const snapshotTree: ISnapshotTree | undefined = isInstanceOfISnapshot(snapshot)
-			? snapshot.snapshotTree
-			: snapshot;
-		if (pendingLocalState) {
-			this.attachmentData = {
-				state: AttachState.Attached,
-				snapshot: {
-					tree: pendingLocalState.baseSnapshot,
-					blobs: pendingLocalState.snapshotBlobs,
-				},
-			};
-		} else {
-			assert(snapshotTree !== undefined, 0x237 /* "Snapshot should exist" */);
-			if (this.offlineLoadEnabled) {
-				const blobs = await getBlobContentsFromTree(snapshotTree, this.storageAdapter);
-				this.attachmentData = {
-					state: AttachState.Attached,
-					snapshot: { tree: snapshotTree, blobs },
-				};
-			}
-		}
-
+		const { snapshotTree, version } = await this.serializedStateManager.fetchSnapshot(
+			specifiedVersion,
+			this.service?.policies?.supportGetSnapshotApi,
+		);
+		this._loadedFromVersion = version;
 		const attributes: IDocumentAttributes = await this.getDocumentAttributes(
 			this.storageAdapter,
 			snapshotTree,
@@ -1727,7 +1686,7 @@ export class Container
 			snapshotTree,
 			// give runtime a dummy value so it knows we're loading from a stash blob
 			pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined,
-			isInstanceOfISnapshot(snapshot) ? snapshot : undefined,
+			isInstanceOfISnapshot(snapshotTree) ? snapshotTree : undefined,
 		);
 
 		// replay saved ops
@@ -1810,7 +1769,7 @@ export class Container
 		);
 		return {
 			sequenceNumber: attributes.sequenceNumber,
-			version: versionId,
+			version: version?.id,
 			dmLastProcessedSeqNumber: this._deltaManager.lastSequenceNumber,
 			dmLastKnownSeqNumber: this._deltaManager.lastKnownSeqNumber,
 		};
@@ -1841,10 +1800,10 @@ export class Container
 	}
 
 	private async rehydrateDetachedFromSnapshot({
-		attached,
 		baseSnapshot,
 		snapshotBlobs,
 		hasAttachmentBlobs,
+		pendingRuntimeState,
 	}: IPendingDetachedContainerState) {
 		if (hasAttachmentBlobs) {
 			assert(
@@ -1878,7 +1837,11 @@ export class Container
 		);
 		const codeDetails = this.getCodeDetailsFromQuorum();
 
-		await this.instantiateRuntime(codeDetails, snapshotTreeWithBlobContents);
+		await this.instantiateRuntime(
+			codeDetails,
+			snapshotTreeWithBlobContents,
+			pendingRuntimeState,
+		);
 
 		this.setLoaded();
 	}
@@ -2022,13 +1985,12 @@ export class Container
 
 	private static setupClient(
 		containerId: string,
-		options?: ILoaderOptions,
+		loaderOptionsClient?: IClient,
 		clientDetailsOverride?: IClientDetails,
 	): IClient {
-		const loaderOptionsClient = structuredClone(options?.client);
 		const client: IClient =
 			loaderOptionsClient !== undefined
-				? (loaderOptionsClient as IClient)
+				? structuredClone(loaderOptionsClient)
 				: {
 						details: {
 							capabilities: { interactive: true },
@@ -2106,10 +2068,10 @@ export class Container
 			this.connectionStateHandler.cancelEstablishingConnection(reason);
 		});
 
-		deltaManager.on("disconnect", (reason: IConnectionStateChangeReason) => {
+		deltaManager.on("disconnect", (text, error) => {
 			this.noopHeuristic?.notifyDisconnect();
 			if (!this.closed) {
-				this.connectionStateHandler.receivedDisconnectEvent(reason);
+				this.connectionStateHandler.receivedDisconnectEvent({ text, error });
 			}
 		});
 
@@ -2333,9 +2295,6 @@ export class Container
 	}
 
 	private processRemoteMessage(message: ISequencedDocumentMessage) {
-		if (this.offlineLoadEnabled) {
-			this.savedOps.push(message);
-		}
 		const local = this.clientId === message.clientId;
 
 		// Allow the protocol handler to process the message
@@ -2343,7 +2302,7 @@ export class Container
 
 		// Forward messages to the loaded runtime for processing
 		this.runtime.process(message, local);
-
+		this.serializedStateManager.addProcessedOp(message);
 		// Inactive (not in quorum or not writers) clients don't take part in the minimum sequence number calculation.
 		if (this.activeConnection()) {
 			if (this.noopHeuristic === undefined) {
@@ -2396,60 +2355,6 @@ export class Container
 		}
 	}
 
-	/**
-	 * Get the most recent snapshot, or a specific version.
-	 * @param specifiedVersion - The specific version of the snapshot to retrieve
-	 * @returns The snapshot requested, or the latest snapshot if no version was specified, plus version ID
-	 */
-	private async fetchSnapshotTree(
-		specifiedVersion: string | undefined,
-	): Promise<{ snapshot?: ISnapshotTree; versionId?: string }> {
-		const version = await this.getVersion(specifiedVersion ?? null);
-
-		if (version === undefined && specifiedVersion !== undefined) {
-			// We should have a defined version to load from if specified version requested
-			this.mc.logger.sendErrorEvent({
-				eventName: "NoVersionFoundWhenSpecified",
-				id: specifiedVersion,
-			});
-		}
-		this._loadedFromVersion = version;
-		const snapshot = (await this.storageAdapter.getSnapshotTree(version)) ?? undefined;
-
-		if (snapshot === undefined && version !== undefined) {
-			this.mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
-		}
-		return { snapshot, versionId: version?.id };
-	}
-
-	private async fetchSnapshot(
-		specifiedVersion: string | undefined,
-	): Promise<{ snapshot?: ISnapshot | ISnapshotTree; versionId?: string }> {
-		if (
-			this.mc.config.getBoolean("Fluid.Container.FetchSnapshotUsingGetSnapshotApi") ===
-				true &&
-			this.service?.policies?.supportGetSnapshotApi === true
-		) {
-			const snapshot = await this.storageAdapter.getSnapshot({
-				versionId: specifiedVersion,
-			});
-			const version: IVersion = {
-				id: snapshot.snapshotTree.id ?? "",
-				treeId: snapshot.snapshotTree.id ?? "",
-			};
-			this._loadedFromVersion = version;
-
-			if (snapshot === undefined && specifiedVersion !== undefined) {
-				this.mc.logger.sendErrorEvent({
-					eventName: "getSnapshotTreeFailed",
-					id: version.id,
-				});
-			}
-			return { snapshot, versionId: version.id };
-		}
-		return this.fetchSnapshotTree(specifiedVersion);
-	}
-
 	private async instantiateRuntime(
 		codeDetails: IFluidCodeDetails,
 		snapshotTree: ISnapshotTree | undefined,