@fluidframework/container-loader 2.0.0-rc.1.0.6 → 2.0.0-rc.2.0.1

package/src/containerContext.ts

@@ -16,7 +16,7 @@ import {
 	IBatchMessage,
 } from "@fluidframework/container-definitions";
 import { FluidObject } from "@fluidframework/core-interfaces";
-import { IDocumentStorageService } from "@fluidframework/driver-definitions";
+import { IDocumentStorageService, ISnapshot } from "@fluidframework/driver-definitions";
 import {
 	IClientDetails,
 	IDocumentMessage,
@@ -99,6 +99,7 @@ export class ContainerContext implements IContainerContext {
 		public readonly existing: boolean,
 		public readonly taggedLogger: ITelemetryLoggerExt,
 		public readonly pendingLocalState?: unknown,
+		public readonly snapshotWithContents?: ISnapshot,
 	) {}
 
 	public getLoadedFromVersion(): IVersion | undefined {

package/src/containerStorageAdapter.ts

@@ -13,6 +13,8 @@ import {
 	IDocumentService,
 	IDocumentStorageService,
 	IDocumentStorageServicePolicies,
+	ISnapshot,
+	ISnapshotFetchOptions,
 	ISummaryContext,
 } from "@fluidframework/driver-definitions";
 import { UsageError } from "@fluidframework/driver-utils";
@@ -23,9 +25,9 @@ import {
 	ISummaryTree,
 	IVersion,
 } from "@fluidframework/protocol-definitions";
-import { IDetachedBlobStorage } from "./loader";
-import { ProtocolTreeStorageService } from "./protocolTreeDocumentStorageService";
-import { RetriableDocumentStorageService } from "./retriableDocumentStorageService";
+import { IDetachedBlobStorage } from "./loader.js";
+import { ProtocolTreeStorageService } from "./protocolTreeDocumentStorageService.js";
+import { RetriableDocumentStorageService } from "./retriableDocumentStorageService.js";
 
 /**
  * Stringified blobs from a summary/snapshot tree.
@@ -101,18 +103,9 @@ export class ContainerStorageAdapter implements IDocumentStorageService, IDispos
 		}
 	}
 
-	public loadSnapshotForRehydratingContainer(snapshotTree: ISnapshotTreeWithBlobContents) {
-		this.getBlobContents(snapshotTree);
-	}
-
-	private getBlobContents(snapshotTree: ISnapshotTreeWithBlobContents) {
-		if (snapshotTree.blobsContents !== undefined) {
-			for (const [id, value] of Object.entries(snapshotTree.blobsContents ?? {})) {
-				this.blobContents[id] = value;
-			}
-		}
-		for (const [_, tree] of Object.entries(snapshotTree.trees)) {
-			this.getBlobContents(tree);
+	public loadSnapshotFromSnapshotBlobs(snapshotBlobs: ISerializableBlobContents) {
+		for (const [id, value] of Object.entries(snapshotBlobs)) {
+			this.blobContents[id] = value;
 		}
 	}
 
@@ -125,10 +118,6 @@ export class ContainerStorageAdapter implements IDocumentStorageService, IDispos
 		return undefined;
 	}
 
-	public get repositoryUrl(): string {
-		return this._storageService.repositoryUrl;
-	}
-
 	public async getSnapshotTree(
 		version?: IVersion,
 		scenarioName?: string,
@@ -136,6 +125,15 @@ export class ContainerStorageAdapter implements IDocumentStorageService, IDispos
 		return this._storageService.getSnapshotTree(version, scenarioName);
 	}
 
+	public async getSnapshot(snapshotFetchOptions?: ISnapshotFetchOptions): Promise<ISnapshot> {
+		if (this._storageService.getSnapshot !== undefined) {
+			return this._storageService.getSnapshot(snapshotFetchOptions);
+		}
+		throw new UsageError(
+			"getSnapshot api should exist in internal storage in ContainerStorageAdapter",
+		);
+	}
+
 	public async readBlob(id: string): Promise<ArrayBufferLike> {
 		const maybeBlob = this.blobContents[id];
 		if (maybeBlob !== undefined) {
@@ -202,12 +200,9 @@ class BlobOnlyStorage implements IDocumentStorageService {
 		return this.notCalled();
 	}
 
-	public get repositoryUrl(): string {
-		return this.notCalled();
-	}
-
 	/* eslint-disable @typescript-eslint/unbound-method */
 	public getSnapshotTree: () => Promise<ISnapshotTree | null> = this.notCalled;
+	public getSnapshot: () => Promise<ISnapshot> = this.notCalled;
 	public getVersions: () => Promise<IVersion[]> = this.notCalled;
 	public write: () => Promise<IVersion> = this.notCalled;
 	public uploadSummaryWithContext: () => Promise<string> = this.notCalled;
@@ -239,7 +234,7 @@ const redirectTableBlobName = ".redirectTable";
  */
 export async function getBlobContentsFromTree(
 	snapshot: ISnapshotTree,
-	storage: IDocumentStorageService,
+	storage: Pick<IDocumentStorageService, "readBlob">,
 ): Promise<ISerializableBlobContents> {
 	const blobs = {};
 	await getBlobContentsFromTreeCore(snapshot, blobs, storage);
@@ -249,7 +244,7 @@ export async function getBlobContentsFromTree(
 async function getBlobContentsFromTreeCore(
 	tree: ISnapshotTree,
 	blobs: ISerializableBlobContents,
-	storage: IDocumentStorageService,
+	storage: Pick<IDocumentStorageService, "readBlob">,
 	root = true,
 ) {
 	const treePs: Promise<any>[] = [];
@@ -272,7 +267,7 @@ async function getBlobContentsFromTreeCore(
 async function getBlobManagerTreeFromTree(
 	tree: ISnapshotTree,
 	blobs: ISerializableBlobContents,
-	storage: IDocumentStorageService,
+	storage: Pick<IDocumentStorageService, "readBlob">,
 ) {
 	const id = tree.blobs[redirectTableBlobName];
 	const blob = await storage.readBlob(id);

package/src/contracts.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { IErrorBase, ITelemetryProperties } from "@fluidframework/core-interfaces";
+import { IErrorBase, ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
 import {
 	IConnectionDetails,
 	ICriticalContainerError,
@@ -73,12 +73,12 @@ export interface IConnectionManager {
 	// Various connectivity properties for telemetry describing type of current connection
 	// Things like connection mode, service info, etc.
 	// Called when connection state changes (connect / disconnect)
-	readonly connectionProps: ITelemetryProperties;
+	readonly connectionProps: ITelemetryBaseProperties;
 
 	// Verbose information about connection logged to telemetry in case of issues with
 	// maintaining healthy connection, including op gaps, not receiving join op in time, etc.
 	// Contains details information, like sequence numbers at connection time, initial ops info, etc.
-	readonly connectionVerboseProps: ITelemetryProperties;
+	readonly connectionVerboseProps: ITelemetryBaseProperties;
 
 	/**
 	 * Prepares message to be sent. Fills in clientSequenceNumber.

package/src/debugLogger.ts

@@ -6,7 +6,7 @@
 import {
 	ITelemetryBaseEvent,
 	ITelemetryBaseLogger,
-	ITelemetryProperties,
+	ITelemetryBaseProperties,
 } from "@fluidframework/core-interfaces";
 import { performance } from "@fluid-internal/client-utils";
 
@@ -77,7 +77,7 @@ export class DebugLogger implements ITelemetryBaseLogger {
 	 * @param event - the event to send
 	 */
 	public send(event: ITelemetryBaseEvent): void {
-		const newEvent: ITelemetryProperties = { ...event };
+		const newEvent: ITelemetryBaseProperties = { ...event };
 		const isError = newEvent.category === "error";
 		let logger = isError ? this.debugErr : this.debug;
 

package/src/deltaManager.ts

@@ -7,8 +7,7 @@ import { v4 as uuid } from "uuid";
 import {
 	IThrottlingWarning,
 	IEventProvider,
-	ITelemetryProperties,
-	ITelemetryErrorEvent,
+	ITelemetryBaseProperties,
 	type ITelemetryBaseEvent,
 } from "@fluidframework/core-interfaces";
 import {
@@ -29,6 +28,7 @@ import {
 	DataCorruptionError,
 	UsageError,
 	type ITelemetryGenericEventExt,
+	type ITelemetryErrorEventExt,
 } from "@fluidframework/telemetry-utils";
 import {
 	IDocumentDeltaStorageService,
@@ -49,9 +49,9 @@ import {
 	IConnectionManager,
 	IConnectionManagerFactoryArgs,
 	IConnectionStateChangeReason,
-} from "./contracts";
-import { DeltaQueue } from "./deltaQueue";
-import { ThrottlingWarning } from "./error";
+} from "./contracts.js";
+import { DeltaQueue } from "./deltaQueue.js";
+import { ThrottlingWarning } from "./error.js";
 
 export interface IConnectionArgs {
 	mode?: ConnectionMode;
@@ -361,7 +361,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		assert(this.messageBuffer.length === 0, 0x3cc /* reentrancy */);
 	}
 
-	public get connectionProps(): ITelemetryProperties {
+	public get connectionProps(): ITelemetryBaseProperties {
 		return {
 			sequenceNumber: this.lastSequenceNumber,
 			opsSize: this.opsSize > 0 ? this.opsSize : undefined,
@@ -376,7 +376,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	 * we stop processing ops that results in no processing join op and thus moving to connected state)
 	 * @param event - Event to log.
 	 */
-	public logConnectionIssue(event: ITelemetryErrorEvent) {
+	public logConnectionIssue(event: ITelemetryErrorEventExt) {
 		assert(this.connectionManager.connected, 0x238 /* "called only in connected state" */);
 
 		const pendingSorted = this.pending.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
@@ -797,7 +797,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 
 	private disconnectHandler(reason: IConnectionStateChangeReason) {
 		this.messageBuffer.length = 0;
-		this.emit("disconnect", reason);
+		this.emit("disconnect", reason.text, reason.error);
 	}
 
 	/**

package/src/error.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryProperties, IThrottlingWarning } from "@fluidframework/core-interfaces";
+import { ITelemetryBaseProperties, IThrottlingWarning } from "@fluidframework/core-interfaces";
 import { ContainerErrorTypes } from "@fluidframework/container-definitions";
 import {
 	IFluidErrorBase,
@@ -24,7 +24,7 @@ export class ThrottlingWarning extends LoggingError implements IThrottlingWarnin
 	private constructor(
 		message: string,
 		readonly retryAfterSeconds: number,
-		props?: ITelemetryProperties,
+		props?: ITelemetryBaseProperties,
 	) {
 		super(message, props);
 	}

package/src/index.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-export { ConnectionState } from "./connectionState";
-export { IContainerExperimental, waitContainerToCatchUp } from "./container";
+export { ConnectionState } from "./connectionState.js";
+export { IContainerExperimental, waitContainerToCatchUp } from "./container.js";
 export {
 	ICodeDetailsLoader,
 	IDetachedBlobStorage,
@@ -13,10 +13,10 @@ export {
 	ILoaderProps,
 	ILoaderServices,
 	Loader,
-} from "./loader";
+} from "./loader.js";
 export {
 	isLocationRedirectionError,
 	resolveWithLocationRedirectionHandling,
-} from "./location-redirection-utilities";
-export { IProtocolHandler, ProtocolHandlerBuilder } from "./protocol";
-export { tryParseCompatibleResolvedUrl, IParsedUrl } from "./utils";
+} from "./location-redirection-utilities/index.js";
+export { IProtocolHandler, ProtocolHandlerBuilder } from "./protocol.js";
+export { tryParseCompatibleResolvedUrl, IParsedUrl } from "./utils.js";

package/src/loader.ts

@@ -36,11 +36,11 @@ import {
 	IUrlResolver,
 } from "@fluidframework/driver-definitions";
 import { IClientDetails } from "@fluidframework/protocol-definitions";
-import { Container, IPendingContainerState } from "./container";
-import { IParsedUrl, tryParseCompatibleResolvedUrl } from "./utils";
-import { pkgVersion } from "./packageVersion";
-import { ProtocolHandlerBuilder } from "./protocol";
-import { DebugLogger } from "./debugLogger";
+import { Container, IPendingContainerState } from "./container.js";
+import { tryParseCompatibleResolvedUrl } from "./utils.js";
+import { pkgVersion } from "./packageVersion.js";
+import { ProtocolHandlerBuilder } from "./protocol.js";
+import { DebugLogger } from "./debugLogger.js";
 
 function ensureResolvedUrlDefined(
 	resolved: IResolvedUrl | undefined,
@@ -108,7 +108,7 @@ export interface IFluidModuleWithDetails {
 }
 
 /**
- * @deprecated ICodeDetailsLoader interface is moved to {@link @fluidframework/container-definition#ICodeDetailsLoader}
+ * @deprecated ICodeDetailsLoader interface is moved to {@link @fluidframework/container-definitions#ICodeDetailsLoader}
  * to have code loading modules in one package. #8193
  * Fluid code loader resolves a code module matching the document schema, i.e. code details, such as
  * a package name and package version range.
@@ -332,18 +332,17 @@ export class Loader implements IHostLoader {
 	public async resolve(request: IRequest, pendingLocalState?: string): Promise<IContainer> {
 		const eventName = pendingLocalState === undefined ? "Resolve" : "ResolveWithPendingState";
 		return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName }, async () => {
-			const resolved = await this.resolveCore(
+			return this.resolveCore(
 				request,
 				pendingLocalState !== undefined ? JSON.parse(pendingLocalState) : undefined,
 			);
-			return resolved.container;
 		});
 	}
 
 	private async resolveCore(
 		request: IRequest,
 		pendingLocalState?: IPendingContainerState,
-	): Promise<{ container: Container; parsed: IParsedUrl }> {
+	): Promise<Container> {
 		const resolvedAsFluid = await this.services.urlResolver.resolve(request);
 		ensureResolvedUrlDefined(resolvedAsFluid);
 
@@ -387,10 +386,7 @@ export class Loader implements IHostLoader {
 			throw new UsageError('opsBeforeReturn must be set to "sequenceNumber"');
 		}
 
-		return {
-			container: await this.loadContainer(request, resolvedAsFluid, pendingLocalState),
-			parsed,
-		};
+		return this.loadContainer(request, resolvedAsFluid, pendingLocalState);
 	}
 
 	private async loadContainer(

package/src/location-redirection-utilities/index.ts

@@ -6,4 +6,4 @@
 export {
 	isLocationRedirectionError,
 	resolveWithLocationRedirectionHandling,
-} from "./resolveWithLocationRedirection";
+} from "./resolveWithLocationRedirection.js";

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "2.0.0-rc.1.0.6";
+export const pkgVersion = "2.0.0-rc.2.0.1";

package/src/protocolTreeDocumentStorageService.ts

@@ -19,14 +19,12 @@ export class ProtocolTreeStorageService implements IDocumentStorageService, IDis
 	public get policies() {
 		return this.internalStorageService.policies;
 	}
-	public get repositoryUrl() {
-		return this.internalStorageService.repositoryUrl;
-	}
 	public get disposed() {
 		return this.internalStorageService.disposed;
 	}
 
 	getSnapshotTree = this.internalStorageService.getSnapshotTree.bind(this.internalStorageService);
+	getSnapshot = this.internalStorageService.getSnapshot?.bind(this.internalStorageService);
 	getVersions = this.internalStorageService.getVersions.bind(this.internalStorageService);
 	createBlob = this.internalStorageService.createBlob.bind(this.internalStorageService);
 	readBlob = this.internalStorageService.readBlob.bind(this.internalStorageService);

package/src/retriableDocumentStorageService.ts

@@ -8,6 +8,8 @@ import {
 	FetchSource,
 	IDocumentStorageService,
 	IDocumentStorageServicePolicies,
+	ISnapshot,
+	ISnapshotFetchOptions,
 	ISummaryContext,
 } from "@fluidframework/driver-definitions";
 import {
@@ -18,7 +20,7 @@ import {
 	IVersion,
 } from "@fluidframework/protocol-definitions";
 import { IDisposable } from "@fluidframework/core-interfaces";
-import { GenericError, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { GenericError, ITelemetryLoggerExt, UsageError } from "@fluidframework/telemetry-utils";
 import { runWithRetry } from "@fluidframework/driver-utils";
 
 export class RetriableDocumentStorageService implements IDocumentStorageService, IDisposable {
@@ -44,13 +46,6 @@ export class RetriableDocumentStorageService implements IDocumentStorageService,
 		this._disposed = true;
 	}
 
-	public get repositoryUrl(): string {
-		if (this.internalStorageService) {
-			return this.internalStorageService.repositoryUrl;
-		}
-		throw new Error("storage service not yet instantiated");
-	}
-
 	public async getSnapshotTree(
 		version?: IVersion,
 		scenarioName?: string,
@@ -64,6 +59,21 @@ export class RetriableDocumentStorageService implements IDocumentStorageService,
 		);
 	}
 
+	public async getSnapshot(snapshotFetchOptions?: ISnapshotFetchOptions): Promise<ISnapshot> {
+		return this.runWithRetry(
+			async () =>
+				this.internalStorageServiceP.then(async (s) => {
+					if (s.getSnapshot !== undefined) {
+						return s.getSnapshot(snapshotFetchOptions);
+					}
+					throw new UsageError(
+						"getSnapshot api should exist on internal storage in RetriableDocStorageService class",
+					);
+				}),
+			"storage_getSnapshot",
+		);
+	}
+
 	public async readBlob(id: string): Promise<ArrayBufferLike> {
 		return this.runWithRetry(
 			async () => this.internalStorageServiceP.then(async (s) => s.readBlob(id)),

package/src/serializedStateManager.ts

@@ -0,0 +1,217 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	ISequencedDocumentMessage,
+	ISnapshotTree,
+	IVersion,
+} from "@fluidframework/protocol-definitions";
+import { IGetPendingLocalStateProps, IRuntime } from "@fluidframework/container-definitions";
+import {
+	ITelemetryLoggerExt,
+	MonitoringContext,
+	PerformanceEvent,
+	UsageError,
+	createChildMonitoringContext,
+} from "@fluidframework/telemetry-utils";
+import { assert } from "@fluidframework/core-utils";
+import {
+	IDocumentStorageService,
+	IResolvedUrl,
+	ISnapshot,
+} from "@fluidframework/driver-definitions";
+import { isInstanceOfISnapshot } from "@fluidframework/driver-utils";
+import { ISerializableBlobContents, getBlobContentsFromTree } from "./containerStorageAdapter.js";
+import { IPendingContainerState } from "./container.js";
+
+export class SerializedStateManager {
+	private readonly processedOps: ISequencedDocumentMessage[] = [];
+	private snapshot:
+		| {
+				tree: ISnapshotTree;
+				blobs: ISerializableBlobContents;
+		  }
+		| undefined;
+	private readonly mc: MonitoringContext;
+
+	constructor(
+		private readonly pendingLocalState: IPendingContainerState | undefined,
+		subLogger: ITelemetryLoggerExt,
+		private readonly storageAdapter: Pick<
+			IDocumentStorageService,
+			"readBlob" | "getSnapshotTree" | "getSnapshot" | "getVersions"
+		>,
+		private readonly _offlineLoadEnabled: boolean,
+	) {
+		this.mc = createChildMonitoringContext({
+			logger: subLogger,
+			namespace: "serializedStateManager",
+		});
+	}
+
+	public get offlineLoadEnabled(): boolean {
+		return this._offlineLoadEnabled;
+	}
+
+	public addProcessedOp(message: ISequencedDocumentMessage) {
+		if (this.offlineLoadEnabled) {
+			this.processedOps.push(message);
+		}
+	}
+
+	private async getVersion(version: string | null): Promise<IVersion | undefined> {
+		const versions = await this.storageAdapter.getVersions(version, 1);
+		return versions[0];
+	}
+
+	public async fetchSnapshot(
+		specifiedVersion: string | undefined,
+		supportGetSnapshotApi: boolean | undefined,
+	) {
+		const { snapshot, version } =
+			this.pendingLocalState === undefined
+				? await this.fetchSnapshotCore(specifiedVersion, supportGetSnapshotApi)
+				: { snapshot: this.pendingLocalState.baseSnapshot, version: undefined };
+		const snapshotTree: ISnapshotTree | undefined = isInstanceOfISnapshot(snapshot)
+			? snapshot.snapshotTree
+			: snapshot;
+		if (this.pendingLocalState) {
+			this.snapshot = {
+				tree: this.pendingLocalState.baseSnapshot,
+				blobs: this.pendingLocalState.snapshotBlobs,
+			};
+		} else {
+			assert(snapshotTree !== undefined, 0x8e4 /* Snapshot should exist */);
+			// non-interactive clients will not have any pending state we want to save
+			if (this.offlineLoadEnabled) {
+				const blobs = await getBlobContentsFromTree(snapshotTree, this.storageAdapter);
+				this.snapshot = { tree: snapshotTree, blobs };
+			}
+		}
+		return { snapshotTree, version };
+	}
+
+	private async fetchSnapshotCore(
+		specifiedVersion: string | undefined,
+		supportGetSnapshotApi: boolean | undefined,
+	): Promise<{ snapshot?: ISnapshot | ISnapshotTree; version?: IVersion }> {
+		if (
+			this.mc.config.getBoolean("Fluid.Container.UseLoadingGroupIdForSnapshotFetch") ===
+				true &&
+			supportGetSnapshotApi === true
+		) {
+			const snapshot =
+				(await this.storageAdapter.getSnapshot?.({
+					versionId: specifiedVersion,
+				})) ?? undefined;
+			const version: IVersion | undefined =
+				snapshot?.snapshotTree.id === undefined
+					? undefined
+					: {
+							id: snapshot.snapshotTree.id,
+							treeId: snapshot.snapshotTree.id,
+					  };
+
+			if (snapshot === undefined && specifiedVersion !== undefined) {
+				this.mc.logger.sendErrorEvent({
+					eventName: "getSnapshotTreeFailed",
+					id: specifiedVersion,
+				});
+				// Not sure if this should be here actually
+			} else if (snapshot !== undefined && version?.id === undefined) {
+				this.mc.logger.sendErrorEvent({
+					eventName: "getSnapshotFetchedTreeWithoutVersionId",
+					hasVersion: version !== undefined, // if hasVersion is true, this means that the contract with the service was broken.
+				});
+			}
+			return { snapshot, version };
+		}
+		return this.fetchSnapshotTree(specifiedVersion);
+	}
+
+	/**
+	 * 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; version?: IVersion | undefined }> {
+		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,
+			});
+		}
+		const snapshot = (await this.storageAdapter.getSnapshotTree(version)) ?? undefined;
+
+		if (snapshot === undefined && version !== undefined) {
+			this.mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
+		} else if (snapshot !== undefined && version?.id === undefined) {
+			this.mc.logger.sendErrorEvent({
+				eventName: "getSnapshotFetchedTreeWithoutVersionId",
+				hasVersion: version !== undefined, // if hasVersion is true, this means that the contract with the service was broken.
+			});
+		}
+		return { snapshot, version };
+	}
+
+	/**
+	 * This method is only meant to be used by Container.attach() to set the initial
+	 * base snapshot when attaching.
+	 * @param snapshot - snapshot and blobs collected while attaching
+	 */
+	public setSnapshot(
+		snapshot:
+			| {
+					tree: ISnapshotTree;
+					blobs: ISerializableBlobContents;
+			  }
+			| undefined,
+	) {
+		this.snapshot = snapshot;
+	}
+
+	public async getPendingLocalStateCore(
+		props: IGetPendingLocalStateProps,
+		clientId: string | undefined,
+		runtime: Pick<IRuntime, "getPendingLocalState">,
+		resolvedUrl: IResolvedUrl,
+	) {
+		return PerformanceEvent.timedExecAsync(
+			this.mc.logger,
+			{
+				eventName: "getPendingLocalState",
+				notifyImminentClosure: props.notifyImminentClosure,
+				processedOpsSize: this.processedOps.length,
+				clientId,
+			},
+			async () => {
+				if (!this.offlineLoadEnabled) {
+					throw new UsageError(
+						"Can't get pending local state unless offline load is enabled",
+					);
+				}
+				assert(this.snapshot !== undefined, 0x8e5 /* no base data */);
+				const pendingRuntimeState = await runtime.getPendingLocalState(props);
+				const pendingState: IPendingContainerState = {
+					attached: true,
+					pendingRuntimeState,
+					baseSnapshot: this.snapshot.tree,
+					snapshotBlobs: this.snapshot.blobs,
+					savedOps: this.processedOps,
+					url: resolvedUrl.url,
+					// no need to save this if there is no pending runtime state
+					clientId: pendingRuntimeState !== undefined ? clientId : undefined,
+				};
+
+				return JSON.stringify(pendingState);
+			},
+		);
+	}
+}