@fluidframework/container-loader 2.0.0-dev.3.1.0.125672 → 2.0.0-dev.4.1.0.148229

package/src/container.ts

@@ -12,10 +12,10 @@ import {
 	TelemetryEventCategory,
 } from "@fluidframework/common-definitions";
 import { assert, performance, unreachableCase } from "@fluidframework/common-utils";
-import { IRequest, IResponse, IFluidRouter } from "@fluidframework/core-interfaces";
+import { IRequest, IResponse, IFluidRouter, FluidObject } from "@fluidframework/core-interfaces";
 import {
 	IAudience,
-	IConnectionDetails,
+	IConnectionDetailsInternal,
 	IContainer,
 	IContainerEvents,
 	IDeltaManager,
@@ -44,6 +44,7 @@ import {
 	combineAppAndProtocolSummary,
 	runWithRetry,
 	isFluidResolvedUrl,
+	isCombinedAppAndProtocolSummary,
 } from "@fluidframework/driver-utils";
 import { IQuorumSnapshot } from "@fluidframework/protocol-base";
 import {
@@ -53,7 +54,6 @@ import {
 	ICommittedProposal,
 	IDocumentAttributes,
 	IDocumentMessage,
-	IProtocolState,
 	IQuorumClients,
 	IQuorumProposals,
 	ISequencedClient,
@@ -74,7 +74,6 @@ import {
 	raiseConnectedEvent,
 	TelemetryLogger,
 	connectedEventName,
-	disconnectedEventName,
 	normalizeError,
 	MonitoringContext,
 	loggerToMonitoringContext,
@@ -87,7 +86,12 @@ import { DeltaManager, IConnectionArgs } from "./deltaManager";
 import { DeltaManagerProxy } from "./deltaManagerProxy";
 import { ILoaderOptions, Loader, RelativeLoader } from "./loader";
 import { pkgVersion } from "./packageVersion";
-import { ContainerStorageAdapter } from "./containerStorageAdapter";
+import {
+	ContainerStorageAdapter,
+	getBlobContentsFromTree,
+	getBlobContentsFromTreeWithBlobContents,
+	ISerializableBlobContents,
+} from "./containerStorageAdapter";
 import { IConnectionStateHandler, createConnectionStateHandler } from "./connectionStateHandler";
 import { getProtocolSnapshotTree, getSnapshotTreeFromSerializedContainer } from "./utils";
 import {
@@ -105,6 +109,10 @@ const detachedContainerRefSeqNumber = 0;
 const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
 
+/**
+ * @deprecated this is an internal interface and will not longer be exported in future versions
+ * @internal
+ */
 export interface IContainerLoadOptions {
 	/**
 	 * Disables the Container from reconnecting if false, allows reconnect otherwise.
@@ -125,6 +133,10 @@ export interface IContainerLoadOptions {
 	loadMode?: IContainerLoadMode;
 }
 
+/**
+ * @deprecated this is an internal interface and will not longer be exported in future versions
+ * @internal
+ */
 export interface IContainerConfig {
 	resolvedUrl?: IFluidResolvedUrl;
 	canReconnect?: boolean;
@@ -255,17 +267,36 @@ export async function ReportIfTooLong(
 /**
  * State saved by a container at close time, to be used to load a new instance
  * of the container to the same state
+ * @deprecated this is an internal interface and will not longer be exported in future versions
+ * @internal
  */
 export interface IPendingContainerState {
 	pendingRuntimeState: unknown;
+	/**
+	 * Snapshot from which container initially loaded.
+	 */
+	baseSnapshot: ISnapshotTree;
+	/**
+	 * Serializable blobs from the base snapshot. Used to load offline since
+	 * storage is not available.
+	 */
+	snapshotBlobs: ISerializableBlobContents;
+	/**
+	 * All ops since base snapshot sequence number up to the latest op
+	 * seen when the container was closed. Used to apply stashed (saved pending)
+	 * ops at the same sequence number at which they were made.
+	 */
+	savedOps: ISequencedDocumentMessage[];
 	url: string;
-	protocol: IProtocolState;
 	term: number;
 	clientId?: string;
 }
 
 const summarizerClientType = "summarizer";
 
+/**
+ * @deprecated - In the next release Container will no longer be exported, IContainer should be used in its place.
+ */
 export class Container
 	extends EventEmitterWithErrorHandling<IContainerEvents>
 	implements IContainer
@@ -274,6 +305,7 @@ export class Container
 
 	/**
 	 * Load an existing container.
+	 * @internal
 	 */
 	public static async load(
 		loader: Loader,
@@ -434,9 +466,9 @@ export class Container
 
 	private _attachState = AttachState.Detached;
 
-	private readonly storageService: ContainerStorageAdapter;
+	private readonly storageAdapter: ContainerStorageAdapter;
 	public get storage(): IDocumentStorageService {
-		return this.storageService;
+		return this.storageAdapter;
 	}
 
 	private readonly clientDetailsOverride: IClientDetails | undefined;
@@ -467,6 +499,9 @@ export class Container
 	private _resolvedUrl: IFluidResolvedUrl | undefined;
 	private attachStarted = false;
 	private _dirtyContainer = false;
+	private readonly savedOps: ISequencedDocumentMessage[] = [];
+	private baseSnapshot?: ISnapshotTree;
+	private baseSnapshotBlobs?: ISerializableBlobContents;
 
 	private lastVisible: number | undefined;
 	private readonly visibilityEventHandler: (() => void) | undefined;
@@ -549,6 +584,14 @@ export class Container
 		return this._deltaManager.clientDetails;
 	}
 
+	private get offlineLoadEnabled(): boolean {
+		// summarizer will not have any pending state we want to save
+		return (
+			(this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad") ?? false) &&
+			this.clientDetails.capabilities.interactive
+		);
+	}
+
 	/**
 	 * Get the code details that are currently specified for the container.
 	 * @returns The current code details if any are specified, undefined if none are specified.
@@ -596,6 +639,44 @@ export class Container
 		return this.loader.services.codeLoader;
 	}
 
+	/**
+	 * {@inheritDoc @fluidframework/container-definitions#IContainer.entryPoint}
+	 */
+	public async getEntryPoint?(): Promise<FluidObject | undefined> {
+		// Only the disposing/disposed lifecycle states should prevent access to the entryPoint; closing/closed should still
+		// allow it since they mean a kind of read-only state for the Container.
+		// Note that all 4 are lifecycle states but only 'closed' and 'disposed' are emitted as events.
+		if (this._lifecycleState === "disposing" || this._lifecycleState === "disposed") {
+			throw new UsageError("The container is disposing or disposed");
+		}
+		while (this._context === undefined) {
+			await new Promise<void>((resolve, reject) => {
+				const contextChangedHandler = () => {
+					resolve();
+					this.off("disposed", disposedHandler);
+				};
+				const disposedHandler = (error) => {
+					reject(error ?? "The Container is disposed");
+					this.off("contextChanged", contextChangedHandler);
+				};
+				this.once("contextChanged", contextChangedHandler);
+				this.once("disposed", disposedHandler);
+			});
+			// The Promise above should only resolve (vs reject) if the 'contextChanged' event was emitted and that
+			// should have set this._context; making sure.
+			assert(
+				this._context !== undefined,
+				0x5a2 /* Context still not defined after contextChanged event */,
+			);
+		}
+		// Disable lint rule for the sake of more complete stack traces
+		// eslint-disable-next-line no-return-await
+		return await this._context.getEntryPoint?.();
+	}
+
+	/**
+	 * @internal
+	 */
 	constructor(
 		private readonly loader: Loader,
 		config: IContainerConfig,
@@ -650,6 +731,7 @@ export class Container
 				dmLastMsqSeqNumber: () => this.deltaManager?.lastMessage?.sequenceNumber,
 				dmLastMsqSeqTimestamp: () => this.deltaManager?.lastMessage?.timestamp,
 				dmLastMsqSeqClientId: () => this.deltaManager?.lastMessage?.clientId,
+				dmLastMsgClientSeq: () => this.deltaManager?.lastMessage?.clientSequenceNumber,
 				connectionStateDuration: () =>
 					performance.now() - this.connectionTransitionTimes[this.connectionState],
 			},
@@ -658,18 +740,12 @@ export class Container
 		// Prefix all events in this file with container-loader
 		this.mc = loggerToMonitoringContext(ChildLogger.create(this.subLogger, "Container"));
 
-		const summarizeProtocolTree =
-			this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2") ??
-			this.loader.services.options.summarizeProtocolTree;
-
 		this.options = {
 			...this.loader.services.options,
-			summarizeProtocolTree,
 		};
 
 		this._deltaManager = this.createDeltaManager();
 
-		this._clientId = config.serializedContainerState?.clientId;
 		this.connectionStateHandler = createConnectionStateHandler(
 			{
 				logger: this.mc.logger,
@@ -725,19 +801,33 @@ export class Container
 				},
 			},
 			this.deltaManager,
-			this._clientId,
+			config.serializedContainerState?.clientId,
 		);
 
 		this.on(savedContainerEvent, () => {
 			this.connectionStateHandler.containerSaved();
 		});
 
-		this.storageService = new ContainerStorageAdapter(
+		// We expose our storage publicly, so it's possible others may call uploadSummaryWithContext() with a
+		// non-combined summary tree (in particular, ContainerRuntime.submitSummary).  We'll intercept those calls
+		// using this callback and fix them up.
+		const addProtocolSummaryIfMissing = (summaryTree: ISummaryTree) =>
+			isCombinedAppAndProtocolSummary(summaryTree) === true
+				? summaryTree
+				: combineAppAndProtocolSummary(summaryTree, this.captureProtocolSummary());
+
+		// Whether the combined summary tree has been forced on by either the loader option or the monitoring context.
+		// Even if not forced on via this flag, combined summaries may still be enabled by service policy.
+		const forceEnableSummarizeProtocolTree =
+			this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2") ??
+			this.loader.services.options.summarizeProtocolTree;
+
+		this.storageAdapter = new ContainerStorageAdapter(
 			this.loader.services.detachedBlobStorage,
 			this.mc.logger,
-			this.options.summarizeProtocolTree === true
-				? () => this.captureProtocolSummary()
-				: undefined,
+			config.serializedContainerState?.snapshotBlobs,
+			addProtocolSummaryIfMissing,
+			forceEnableSummarizeProtocolTree,
 		);
 
 		const isDomAvailable =
@@ -760,43 +850,6 @@ export class Container
 			};
 			document.addEventListener("visibilitychange", this.visibilityEventHandler);
 		}
-
-		// We observed that most users of platform do not check Container.connected event on load, causing bugs.
-		// As such, we are raising events when new listener pops up.
-		// Note that we can raise both "disconnected" & "connect" events at the same time,
-		// if we are in connecting stage.
-		this.on("newListener", (event: string, listener: (...args: any[]) => void) => {
-			// Fire events on the end of JS turn, giving a chance for caller to be in consistent state.
-			Promise.resolve()
-				.then(() => {
-					switch (event) {
-						case dirtyContainerEvent:
-							if (this._dirtyContainer) {
-								listener();
-							}
-							break;
-						case savedContainerEvent:
-							if (!this._dirtyContainer) {
-								listener();
-							}
-							break;
-						case connectedEventName:
-							if (this.connected) {
-								listener(this.clientId);
-							}
-							break;
-						case disconnectedEventName:
-							if (!this.connected) {
-								listener();
-							}
-							break;
-						default:
-					}
-				})
-				.catch((error) => {
-					this.mc.logger.sendErrorEvent({ eventName: "RaiseConnectedEventError" }, error);
-				});
-		});
 	}
 
 	/**
@@ -840,10 +893,15 @@ export class Container
 			try {
 				// Raise event first, to ensure we capture _lifecycleState before transition.
 				// This gives us a chance to know what errors happened on open vs. on fully loaded container.
+				// Log generic events instead of error events if container is in loading state, as most errors are not really FF errors
+				// which can pollute telemetry for real bugs
 				this.mc.logger.sendTelemetryEvent(
 					{
 						eventName: "ContainerClose",
-						category: error === undefined ? "generic" : "error",
+						category:
+							this._lifecycleState !== "loading" && error !== undefined
+								? "error"
+								: "generic",
 					},
 					error,
 				);
@@ -856,7 +914,7 @@ export class Container
 
 				this._context?.dispose(error !== undefined ? new Error(error.message) : undefined);
 
-				this.storageService.dispose();
+				this.storageAdapter.dispose();
 
 				// Notify storage about critical errors. They may be due to disconnect between client & server knowledge
 				// about file, like file being overwritten in storage, but client having stale local cache.
@@ -889,7 +947,7 @@ export class Container
 				this.mc.logger.sendTelemetryEvent(
 					{
 						eventName: "ContainerDispose",
-						category: error === undefined ? "generic" : "error",
+						category: "generic",
 					},
 					error,
 				);
@@ -905,7 +963,7 @@ export class Container
 
 				this._context?.dispose(error !== undefined ? new Error(error.message) : undefined);
 
-				this.storageService.dispose();
+				this.storageAdapter.dispose();
 
 				// Notify storage about critical errors. They may be due to disconnect between client & server knowledge
 				// about file, like file being overwritten in storage, but client having stale local cache.
@@ -933,6 +991,9 @@ export class Container
 		// runtime matches pending ops to successful ones by clientId and client seq num, so we need to close the
 		// container at the same time we get pending state, otherwise this container could reconnect and resubmit with
 		// a new clientId and a future container using stale pending state without the new clientId would resubmit them
+		if (!this.offlineLoadEnabled) {
+			throw new UsageError("Can't get pending local state unless offline load is enabled");
+		}
 		assert(
 			this.attachState === AttachState.Attached,
 			0x0d1 /* "Container should be attached before close" */,
@@ -946,10 +1007,14 @@ export class Container
 			this._protocolHandler.attributes.term !== undefined,
 			0x37e /* Must have a valid protocol handler instance */,
 		);
+		assert(!!this.baseSnapshot, "no base snapshot");
+		assert(!!this.baseSnapshotBlobs, "no snapshot blobs");
 		const pendingState: IPendingContainerState = {
 			pendingRuntimeState: this.context.getPendingLocalState(),
+			baseSnapshot: this.baseSnapshot,
+			snapshotBlobs: this.baseSnapshotBlobs,
+			savedOps: this.savedOps,
 			url: this.resolvedUrl.url,
-			protocol: this.protocolHandler.getProtocolState(),
 			term: this._protocolHandler.attributes.term,
 			clientId: this.clientId,
 		};
@@ -1031,9 +1096,13 @@ export class Container
 						// starting to attach the container to storage.
 						// Also, this should only be fired in detached container.
 						this._attachState = AttachState.Attaching;
-						this.context.notifyAttaching(
-							getSnapshotTreeFromSerializedContainer(summary),
-						);
+						this.emit("attaching");
+						if (this.offlineLoadEnabled) {
+							const snapshot = getSnapshotTreeFromSerializedContainer(summary);
+							this.baseSnapshot = snapshot;
+							this.baseSnapshotBlobs =
+								getBlobContentsFromTreeWithBlobContents(snapshot);
+						}
 					}
 
 					// Actually go and create the resolved document
@@ -1062,7 +1131,7 @@ export class Container
 					const resolvedUrl = this.service.resolvedUrl;
 					ensureFluidResolvedUrl(resolvedUrl);
 					this._resolvedUrl = resolvedUrl;
-					await this.storageService.connectToService(this.service);
+					await this.storageAdapter.connectToService(this.service);
 
 					if (hasAttachmentBlobs) {
 						// upload blobs to storage
@@ -1082,7 +1151,7 @@ export class Container
 							for (const id of newIds) {
 								const blob =
 									await this.loader.services.detachedBlobStorage.readBlob(id);
-								const response = await this.storageService.createBlob(blob);
+								const response = await this.storageAdapter.createBlob(blob);
 								redirectTable.set(id, response.id);
 							}
 						}
@@ -1093,11 +1162,15 @@ export class Container
 						summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
 
 						this._attachState = AttachState.Attaching;
-						this.context.notifyAttaching(
-							getSnapshotTreeFromSerializedContainer(summary),
-						);
+						this.emit("attaching");
+						if (this.offlineLoadEnabled) {
+							const snapshot = getSnapshotTreeFromSerializedContainer(summary);
+							this.baseSnapshot = snapshot;
+							this.baseSnapshotBlobs =
+								getBlobContentsFromTreeWithBlobContents(snapshot);
+						}
 
-						await this.storageService.uploadSummaryWithContext(summary, {
+						await this.storageAdapter.uploadSummaryWithContext(summary, {
 							referenceSequenceNumber: 0,
 							ackHandle: undefined,
 							proposalHandle: undefined,
@@ -1272,7 +1345,7 @@ export class Container
 	}
 
 	private async getVersion(version: string | null): Promise<IVersion | undefined> {
-		const versions = await this.storageService.getVersions(version, 1);
+		const versions = await this.storageAdapter.getVersions(version, 1);
 		return versions[0];
 	}
 
@@ -1329,15 +1402,15 @@ export class Container
 
 		// Start websocket connection as soon as possible. Note that there is no op handler attached yet, but the
 		// DeltaManager is resilient to this and will wait to start processing ops until after it is attached.
-		if (loadMode.deltaConnection === undefined) {
+		if (loadMode.deltaConnection === undefined && !pendingLocalState) {
 			this.connectToDeltaStream(connectionArgs);
 		}
 
 		if (!pendingLocalState) {
-			await this.storageService.connectToService(this.service);
+			await this.storageAdapter.connectToService(this.service);
 		} else {
 			// if we have pendingLocalState we can load without storage; don't wait for connection
-			this.storageService.connectToService(this.service).catch((error) => {
+			this.storageAdapter.connectToService(this.service).catch((error) => {
 				this.close(error);
 				this.dispose?.(error);
 			});
@@ -1349,20 +1422,30 @@ export class Container
 		const { snapshot, versionId } =
 			pendingLocalState === undefined
 				? await this.fetchSnapshotTree(specifiedVersion)
-				: { snapshot: undefined, versionId: undefined };
-		assert(
-			snapshot !== undefined || pendingLocalState !== undefined,
-			0x237 /* "Snapshot should exist" */,
+				: { snapshot: pendingLocalState.baseSnapshot, versionId: undefined };
+
+		if (pendingLocalState) {
+			this.baseSnapshot = pendingLocalState.baseSnapshot;
+			this.baseSnapshotBlobs = pendingLocalState.snapshotBlobs;
+		} else {
+			assert(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
+			if (this.offlineLoadEnabled) {
+				this.baseSnapshot = snapshot;
+				// Save contents of snapshot now, otherwise closeAndGetPendingLocalState() must be async
+				this.baseSnapshotBlobs = await getBlobContentsFromTree(snapshot, this.storage);
+			}
+		}
+
+		const attributes: IDocumentAttributes = await this.getDocumentAttributes(
+			this.storageAdapter,
+			snapshot,
 		);
 
-		const attributes: IDocumentAttributes =
-			pendingLocalState === undefined
-				? await this.getDocumentAttributes(this.storageService, snapshot)
-				: {
-						sequenceNumber: pendingLocalState.protocol.sequenceNumber,
-						minimumSequenceNumber: pendingLocalState.protocol.minimumSequenceNumber,
-						term: pendingLocalState.term,
-				  };
+		// If we saved ops, we will replay them and don't need DeltaManager to fetch them
+		const sequenceNumber =
+			pendingLocalState?.savedOps[pendingLocalState.savedOps.length - 1]?.sequenceNumber;
+		const dmAttributes =
+			sequenceNumber !== undefined ? { ...attributes, sequenceNumber } : attributes;
 
 		let opsBeforeReturnP: Promise<void> | undefined;
 
@@ -1373,15 +1456,15 @@ export class Container
 				// Start prefetch, but not set opsBeforeReturnP - boot is not blocked by it!
 				// eslint-disable-next-line @typescript-eslint/no-floating-promises
 				this.attachDeltaManagerOpHandler(
-					attributes,
+					dmAttributes,
 					loadMode.deltaConnection !== "none" ? "all" : "none",
 				);
 				break;
 			case "cached":
-				opsBeforeReturnP = this.attachDeltaManagerOpHandler(attributes, "cached");
+				opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, "cached");
 				break;
 			case "all":
-				opsBeforeReturnP = this.attachDeltaManagerOpHandler(attributes, "all");
+				opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, "all");
 				break;
 			default:
 				unreachableCase(loadMode.opsBeforeReturn);
@@ -1389,22 +1472,7 @@ export class Container
 
 		// ...load in the existing quorum
 		// Initialize the protocol handler
-		if (pendingLocalState === undefined) {
-			await this.initializeProtocolStateFromSnapshot(
-				attributes,
-				this.storageService,
-				snapshot,
-			);
-		} else {
-			this.initializeProtocolState(
-				attributes,
-				{
-					members: pendingLocalState.protocol.members,
-					proposals: pendingLocalState.protocol.proposals,
-					values: pendingLocalState.protocol.values,
-				}, // pending IQuorumSnapshot
-			);
-		}
+		await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, snapshot);
 
 		const codeDetails = this.getCodeDetailsFromQuorum();
 		await this.instantiateContext(
@@ -1414,6 +1482,24 @@ export class Container
 			pendingLocalState?.pendingRuntimeState,
 		);
 
+		// replay saved ops
+		if (pendingLocalState) {
+			for (const message of pendingLocalState.savedOps) {
+				this.processRemoteMessage(message);
+
+				// allow runtime to apply stashed ops at this op's sequence number
+				await this.context.notifyOpReplay(message);
+			}
+			pendingLocalState.savedOps = [];
+
+			// now set clientId to stashed clientId so live ops are correctly processed as local
+			assert(
+				this.clientId === undefined,
+				"Unexpected clientId when setting stashed clientId",
+			);
+			this._clientId = pendingLocalState?.clientId;
+		}
+
 		// We might have hit some failure that did not manifest itself in exception in this flow,
 		// do not start op processing in such case - static version of Container.load() will handle it correctly.
 		if (!this.closed) {
@@ -1437,6 +1523,11 @@ export class Container
 
 			switch (loadMode.deltaConnection) {
 				case undefined:
+					if (pendingLocalState) {
+						// connect to delta stream now since we did not before
+						this.connectToDeltaStream(connectionArgs);
+					}
+				// intentional fallthrough
 				case "delayed":
 					assert(
 						this.inboundQueuePausedFromInit,
@@ -1512,15 +1603,15 @@ export class Container
 		}
 
 		const snapshotTree = getSnapshotTreeFromSerializedContainer(detachedContainerSnapshot);
-		this.storageService.loadSnapshotForRehydratingContainer(snapshotTree);
-		const attributes = await this.getDocumentAttributes(this.storageService, snapshotTree);
+		this.storageAdapter.loadSnapshotForRehydratingContainer(snapshotTree);
+		const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshotTree);
 
 		await this.attachDeltaManagerOpHandler(attributes);
 
 		// Initialize the protocol handler
 		const baseTree = getProtocolSnapshotTree(snapshotTree);
 		const qValues = await readAndParse<[string, ICommittedProposal][]>(
-			this.storageService,
+			this.storageAdapter,
 			baseTree.blobs.quorumValues,
 		);
 		const codeDetails = getCodeDetailsFromQuorumValues(qValues);
@@ -1744,7 +1835,7 @@ export class Container
 		// eslint-disable-next-line @typescript-eslint/no-floating-promises
 		deltaManager.inboundSignal.pause();
 
-		deltaManager.on("connect", (details: IConnectionDetails, _opsBehind?: number) => {
+		deltaManager.on("connect", (details: IConnectionDetailsInternal, _opsBehind?: number) => {
 			assert(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
 			this.connectionStateHandler.receivedConnectEvent(details);
 		});
@@ -1923,7 +2014,7 @@ export class Container
 	}
 
 	/** @returns clientSequenceNumber of last message in a batch */
-	private submitBatch(batch: IBatchMessage[]): number {
+	private submitBatch(batch: IBatchMessage[], referenceSequenceNumber?: number): number {
 		let clientSequenceNumber = -1;
 		for (const message of batch) {
 			clientSequenceNumber = this.submitMessage(
@@ -1932,13 +2023,14 @@ export class Container
 				true, // batch
 				message.metadata,
 				message.compression,
+				referenceSequenceNumber,
 			);
 		}
 		this._deltaManager.flush();
 		return clientSequenceNumber;
 	}
 
-	private submitSummaryMessage(summary: ISummaryContent) {
+	private submitSummaryMessage(summary: ISummaryContent, referenceSequenceNumber?: number) {
 		// github #6451: this is only needed for staging so the server
 		// know when the protocol tree is included
 		// this can be removed once all clients send
@@ -1946,11 +2038,14 @@ export class Container
 		if (summary.details === undefined) {
 			summary.details = {};
 		}
-		summary.details.includesProtocolTree = this.options.summarizeProtocolTree === true;
+		summary.details.includesProtocolTree = this.storageAdapter.summarizeProtocolTree;
 		return this.submitMessage(
 			MessageType.Summarize,
 			JSON.stringify(summary),
 			false /* batch */,
+			undefined /* metadata */,
+			undefined /* compression */,
+			referenceSequenceNumber,
 		);
 	}
 
@@ -1960,6 +2055,7 @@ export class Container
 		batch?: boolean,
 		metadata?: any,
 		compression?: string,
+		referenceSequenceNumber?: number,
 	): number {
 		if (this.connectionState !== ConnectionState.Connected) {
 			this.mc.logger.sendErrorEvent({ eventName: "SubmitMessageWithNoConnection", type });
@@ -1968,10 +2064,20 @@ export class Container
 
 		this.messageCountAfterDisconnection += 1;
 		this.collabWindowTracker?.stopSequenceNumberUpdate();
-		return this._deltaManager.submit(type, contents, batch, metadata, compression);
+		return this._deltaManager.submit(
+			type,
+			contents,
+			batch,
+			metadata,
+			compression,
+			referenceSequenceNumber,
+		);
 	}
 
 	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
@@ -2044,7 +2150,7 @@ export class Container
 			});
 		}
 		this._loadedFromVersion = version;
-		const snapshot = (await this.storageService.getSnapshotTree(version)) ?? undefined;
+		const snapshot = (await this.storageAdapter.getSnapshotTree(version)) ?? undefined;
 
 		if (snapshot === undefined && version !== undefined) {
 			this.mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
@@ -2083,8 +2189,10 @@ export class Container
 			loader,
 			(type, contents, batch, metadata) =>
 				this.submitContainerMessage(type, contents, batch, metadata),
-			(summaryOp: ISummaryContent) => this.submitSummaryMessage(summaryOp),
-			(batch: IBatchMessage[]) => this.submitBatch(batch),
+			(summaryOp: ISummaryContent, referenceSequenceNumber?: number) =>
+				this.submitSummaryMessage(summaryOp, referenceSequenceNumber),
+			(batch: IBatchMessage[], referenceSequenceNumber?: number) =>
+				this.submitBatch(batch, referenceSequenceNumber),
 			(message) => this.submitSignal(message),
 			(error?: ICriticalContainerError) => this.dispose?.(error),
 			(error?: ICriticalContainerError) => this.close(error),