@fluidframework/container-loader 2.0.0-rc.4.0.5 → 2.0.0-rc.5.0.0

package/src/connectionStateHandler.ts

@@ -6,8 +6,8 @@
 import { IDeltaManager } from "@fluidframework/container-definitions/internal";
 import { ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
 import { assert, Timer } from "@fluidframework/core-utils/internal";
+import { IClient, ISequencedClient } from "@fluidframework/driver-definitions";
 import { IAnyDriverError } from "@fluidframework/driver-definitions/internal";
-import { IClient, ISequencedClient } from "@fluidframework/protocol-definitions";
 import {
 	type TelemetryEventCategory,
 	ITelemetryLoggerExt,
@@ -260,10 +260,7 @@ class ConnectionStateCatchup extends ConnectionStateHandlerPassThrough {
 				// In addition to that, in its current form, doing this in ConnectionState.CatchingUp is dangerous as
 				// we might get callback right away, and it will screw up state transition (as code outside of switch
 				// statement will overwrite current state).
-				assert(
-					this.catchUpMonitor === undefined,
-					0x3eb /* catchUpMonitor should be gone */,
-				);
+				assert(this.catchUpMonitor === undefined, 0x3eb /* catchUpMonitor should be gone */);
 				this.catchUpMonitor = new CatchUpMonitor(
 					this.deltaManager,
 					this.transitionToConnectedState,
@@ -652,9 +649,6 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 			}
 			this._clientId = this.pendingClientId;
 		} else if (value === ConnectionState.Disconnected) {
-			// Clear pending state immediately to prepare for reconnect
-			this._pendingClientId = undefined;
-
 			if (this.joinTimer.hasTimer) {
 				this.stopjoinTimer();
 			}
@@ -683,8 +677,15 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 			}
 		}
 
-		// Report transition before we propagate event across layers
+		// Report transition
 		this.handler.connectionStateChanged(this._connectionState, oldState, reason);
+
+		// Clear pending state immediately to prepare for reconnect
+		// Do it after calling connectionStateChanged() above, such that our telemetry contains pendingClientId on disconnect events
+		// and we can pair attempts to connect with disconnects (that's the only ID we have if connection did not move far enough before being disconnected)
+		if (value === ConnectionState.Disconnected) {
+			this._pendingClientId = undefined;
+		}
 	}
 
 	protected get membership(): IMembership | undefined {
@@ -731,7 +732,7 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 
 		assert(
 			!this.waitingForLeaveOp,
-			"leave timer can't be set as we have not had access to quorum",
+			0x99d /* leave timer can't be set as we have not had access to quorum */,
 		);
 
 		// This check is required for scenario of loading container from pending state, and ensuring there is no way

package/src/container.ts

@@ -37,6 +37,14 @@ import {
 } from "@fluidframework/core-interfaces";
 import { type ISignalEnvelope } from "@fluidframework/core-interfaces/internal";
 import { assert, isPromiseLike, unreachableCase } from "@fluidframework/core-utils/internal";
+import {
+	IClient,
+	IClientDetails,
+	IQuorumClients,
+	ISequencedClient,
+	ISummaryTree,
+	SummaryType,
+} from "@fluidframework/driver-definitions";
 import {
 	IDocumentService,
 	IDocumentServiceFactory,
@@ -45,6 +53,17 @@ import {
 	ISnapshot,
 	IThrottlingWarning,
 	IUrlResolver,
+	ICommittedProposal,
+	IDocumentAttributes,
+	IDocumentMessage,
+	IQuorumProposals,
+	ISequencedProposal,
+	ISnapshotTree,
+	ISummaryContent,
+	IVersion,
+	MessageType,
+	ISequencedDocumentMessage,
+	ISignalMessage,
 } from "@fluidframework/driver-definitions/internal";
 import {
 	getSnapshotTree,
@@ -56,26 +75,6 @@ import {
 	readAndParse,
 	runWithRetry,
 } from "@fluidframework/driver-utils/internal";
-import { IQuorumSnapshot } from "@fluidframework/protocol-base";
-import {
-	IClient,
-	IClientDetails,
-	ICommittedProposal,
-	IDocumentAttributes,
-	IDocumentMessage,
-	IQuorumClients,
-	IQuorumProposals,
-	ISequencedClient,
-	ISequencedDocumentMessage,
-	ISequencedProposal,
-	ISignalMessage,
-	ISnapshotTree,
-	ISummaryContent,
-	ISummaryTree,
-	IVersion,
-	MessageType,
-	SummaryType,
-} from "@fluidframework/protocol-definitions";
 import {
 	type TelemetryEventCategory,
 	ITelemetryLoggerExt,
@@ -97,11 +96,18 @@ import {
 import structuredClone from "@ungap/structured-clone";
 import { v4 as uuid } from "uuid";
 
-import { AttachProcessProps, AttachmentData, runRetriableAttachProcess } from "./attachment.js";
+import {
+	AttachProcessProps,
+	AttachmentData,
+	runRetriableAttachProcess,
+} from "./attachment.js";
 import { Audience } from "./audience.js";
 import { ConnectionManager } from "./connectionManager.js";
 import { ConnectionState } from "./connectionState.js";
-import { IConnectionStateHandler, createConnectionStateHandler } from "./connectionStateHandler.js";
+import {
+	IConnectionStateHandler,
+	createConnectionStateHandler,
+} from "./connectionStateHandler.js";
 import { ContainerContext } from "./containerContext.js";
 import { ContainerStorageAdapter } from "./containerStorageAdapter.js";
 import {
@@ -114,8 +120,14 @@ import {
 import { DeltaManager, IConnectionArgs } from "./deltaManager.js";
 // eslint-disable-next-line import/no-deprecated
 import { IDetachedBlobStorage, ILoaderOptions, RelativeLoader } from "./loader.js";
+import {
+	serializeMemoryDetachedBlobStorage,
+	createMemoryDetachedBlobStorage,
+	tryInitializeMemoryDetachedBlobStorage,
+} from "./memoryBlobStorage.js";
 import { NoopHeuristic } from "./noopHeuristic.js";
 import { pkgVersion } from "./packageVersion.js";
+import { IQuorumSnapshot } from "./protocol/index.js";
 import {
 	IProtocolHandler,
 	ProtocolHandler,
@@ -138,11 +150,6 @@ import {
 	getSnapshotTreeAndBlobsFromSerializedContainer,
 	runSingle,
 } from "./utils.js";
-import {
-	serializeMemoryDetachedBlobStorage,
-	createMemoryDetachedBlobStorage,
-	tryInitializeMemoryDetachedBlobStorage,
-} from "./memoryBlobStorage.js";
 
 const detachedContainerRefSeqNumber = 0;
 
@@ -269,7 +276,7 @@ export async function waitContainerToCatchUp(container: IContainer) {
 					? wrapError(
 							err,
 							(innerMessage) => new GenericError(`${baseMessage}: ${innerMessage}`),
-					  )
+						)
 					: new GenericError(baseMessage),
 			);
 		};
@@ -328,7 +335,8 @@ export async function waitContainerToCatchUp(container: IContainer) {
 	});
 }
 
-const getCodeProposal = (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)
@@ -384,9 +392,7 @@ export class Container
 
 					const onClosed = (err?: ICriticalContainerError) => {
 						// pre-0.58 error message: containerClosedWithoutErrorDuringLoad
-						reject(
-							err ?? new GenericError("Container closed without error during load"),
-						);
+						reject(err ?? new GenericError("Container closed without error during load"));
 					};
 					container.on("closed", onClosed);
 
@@ -678,6 +684,13 @@ export class Container
 		return this.deltaManager.clientDetails.capabilities.interactive;
 	}
 
+	private supportGetSnapshotApi(): boolean {
+		const supportGetSnapshotApi: boolean =
+			this.mc.config.getBoolean("Fluid.Container.UseLoadingGroupIdForSnapshotFetch2") ===
+				true && this.service?.policies?.supportGetSnapshotApi === true;
+		return supportGetSnapshotApi;
+	}
+
 	/**
 	 * 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.
@@ -905,8 +918,7 @@ export class Container
 						mode,
 						category: this._lifecycleState === "loading" ? "generic" : category,
 						duration:
-							performance.now() -
-							this.connectionTransitionTimes[ConnectionState.CatchingUp],
+							performance.now() - this.connectionTransitionTimes[ConnectionState.CatchingUp],
 						...(details === undefined ? {} : { details: JSON.stringify(details) }),
 					});
 
@@ -958,9 +970,8 @@ export class Container
 				? 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 =
+		// Whether the combined summary tree has been forced on by either the supportedFeatures flag by the service or the the loader option or the monitoring context
+		const enableSummarizeProtocolTree =
 			this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2") ??
 			options.summarizeProtocolTree;
 
@@ -970,7 +981,7 @@ export class Container
 			pendingLocalState?.snapshotBlobs,
 			pendingLocalState?.loadedGroupIdSnapshots,
 			addProtocolSummaryIfMissing,
-			forceEnableSummarizeProtocolTree,
+			enableSummarizeProtocolTree,
 		);
 
 		const offlineLoadEnabled =
@@ -983,7 +994,8 @@ export class Container
 			this.storageAdapter,
 			offlineLoadEnabled,
 			this,
-			() => this.isDirty,
+			() => this._deltaManager.connectionManager.shouldJoinWrite(),
+			() => this.supportGetSnapshotApi(),
 		);
 
 		const isDomAvailable =
@@ -1055,9 +1067,7 @@ export class Container
 					{
 						eventName: "ContainerClose",
 						category:
-							this._lifecycleState !== "loading" && error !== undefined
-								? "error"
-								: "generic",
+							this._lifecycleState !== "loading" && error !== undefined ? "error" : "generic",
 					},
 					error,
 				);
@@ -1129,10 +1139,7 @@ export class Container
 				// Driver need to ensure all caches are cleared on critical errors
 				this.service?.dispose(error);
 			} catch (exception) {
-				this.mc.logger.sendErrorEvent(
-					{ eventName: "ContainerDisposeException" },
-					exception,
-				);
+				this.mc.logger.sendErrorEvent({ eventName: "ContainerDisposeException" }, exception);
 			}
 
 			this.emit("disposed", error);
@@ -1301,8 +1308,7 @@ export class Container
 						async (summary) => {
 							// Actually go and create the resolved document
 							if (this.service === undefined) {
-								const createNewResolvedUrl =
-									await this.urlResolver.resolve(request);
+								const createNewResolvedUrl = await this.urlResolver.resolve(request);
 								assert(
 									this.client.details.type !== summarizerClientType &&
 										createNewResolvedUrl !== undefined,
@@ -1337,9 +1343,7 @@ export class Container
 					});
 
 					// only enable the new behavior if the config is set
-					if (
-						this.mc.config.getBoolean("Fluid.Container.RetryOnAttachFailure") !== true
-					) {
+					if (this.mc.config.getBoolean("Fluid.Container.RetryOnAttachFailure") !== true) {
 						attachP = attachP.catch((error) => {
 							throw normalizeErrorAndClose(error);
 						});
@@ -1348,7 +1352,6 @@ export class Container
 					// If offline load is enabled, attachP will return the attach summary (in Snapshot format) so we can initialize SerializedStateManager
 					const snapshotWithBlobs = await attachP;
 					this.serializedStateManager.setInitialSnapshot(snapshotWithBlobs);
-
 					if (!this.closed) {
 						this.detachedBlobStorage.dispose?.();
 						this.handleDeltaConnectionArg(attachProps?.deltaConnection, {
@@ -1451,7 +1454,9 @@ export class Container
 		this.connectToDeltaStream(args);
 	}
 
-	public readonly getAbsoluteUrl = async (relativeUrl: string): Promise<string | undefined> => {
+	public readonly getAbsoluteUrl = async (
+		relativeUrl: string,
+	): Promise<string | undefined> => {
 		if (this.resolvedUrl === undefined) {
 			return undefined;
 		}
@@ -1615,14 +1620,9 @@ export class Container
 
 		timings.phase2 = performance.now();
 
-		const supportGetSnapshotApi: boolean =
-			this.mc.config.getBoolean("Fluid.Container.UseLoadingGroupIdForSnapshotFetch") ===
-				true && this.service?.policies?.supportGetSnapshotApi === true;
 		// Fetch specified snapshot.
-		const { baseSnapshot, version } = await this.serializedStateManager.fetchSnapshot(
-			specifiedVersion,
-			supportGetSnapshotApi,
-		);
+		const { baseSnapshot, version } =
+			await this.serializedStateManager.fetchSnapshot(specifiedVersion);
 		const baseSnapshotTree: ISnapshotTree | undefined = getSnapshotTree(baseSnapshot);
 		this._loadedFromVersion = version;
 		const attributes: IDocumentAttributes = await getDocumentAttributes(
@@ -1845,18 +1845,12 @@ export class Container
 			const baseTree = getProtocolSnapshotTree(snapshot);
 			[quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] =
 				await Promise.all([
-					readAndParse<[string, ISequencedClient][]>(
-						storage,
-						baseTree.blobs.quorumMembers,
-					),
+					readAndParse<[string, ISequencedClient][]>(storage, baseTree.blobs.quorumMembers),
 					readAndParse<[number, ISequencedProposal, string[]][]>(
 						storage,
 						baseTree.blobs.quorumProposals,
 					),
-					readAndParse<[string, ICommittedProposal][]>(
-						storage,
-						baseTree.blobs.quorumValues,
-					),
+					readAndParse<[string, ICommittedProposal][]>(storage, baseTree.blobs.quorumValues),
 				]);
 		}
 
@@ -1958,7 +1952,7 @@ export class Container
 						permission: [],
 						scopes: [],
 						user: { id: "" },
-				  };
+					};
 
 		if (clientDetailsOverride !== undefined) {
 			client.details = {
@@ -2151,9 +2145,7 @@ export class Container
 				opsBehind,
 				online: OnlineStatus[isOnline()],
 				lastVisible:
-					this.lastVisible !== undefined
-						? performance.now() - this.lastVisible
-						: undefined,
+					this.lastVisible !== undefined ? performance.now() - this.lastVisible : undefined,
 				checkpointSequenceNumber,
 				quorumSize: this._protocolHandler?.quorum.getMembers().size,
 				isDirty: this.isDirty,

package/src/containerContext.ts

@@ -17,17 +17,17 @@ import {
 } from "@fluidframework/container-definitions/internal";
 import { type FluidObject } from "@fluidframework/core-interfaces";
 import { type ISignalEnvelope } from "@fluidframework/core-interfaces/internal";
-import { IDocumentStorageService, ISnapshot } from "@fluidframework/driver-definitions/internal";
+import { IClientDetails, IQuorumClients } from "@fluidframework/driver-definitions";
 import {
-	IClientDetails,
+	IDocumentStorageService,
+	ISnapshot,
 	IDocumentMessage,
-	IQuorumClients,
-	ISequencedDocumentMessage,
 	ISnapshotTree,
 	ISummaryContent,
 	IVersion,
 	MessageType,
-} from "@fluidframework/protocol-definitions";
+	ISequencedDocumentMessage,
+} from "@fluidframework/driver-definitions/internal";
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
 
 /**

package/src/containerStorageAdapter.ts

@@ -7,6 +7,7 @@ import { bufferToString, stringToBuffer } from "@fluid-internal/client-utils";
 import { ISnapshotTreeWithBlobContents } from "@fluidframework/container-definitions/internal";
 import { IDisposable } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
+import { ISummaryHandle, ISummaryTree } from "@fluidframework/driver-definitions";
 import {
 	FetchSource,
 	IDocumentService,
@@ -15,15 +16,11 @@ import {
 	ISnapshot,
 	ISnapshotFetchOptions,
 	ISummaryContext,
-} from "@fluidframework/driver-definitions/internal";
-import { UsageError } from "@fluidframework/driver-utils/internal";
-import {
 	ICreateBlobResponse,
 	ISnapshotTree,
-	ISummaryHandle,
-	ISummaryTree,
 	IVersion,
-} from "@fluidframework/protocol-definitions";
+} from "@fluidframework/driver-definitions/internal";
+import { UsageError } from "@fluidframework/driver-utils/internal";
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
 
 // eslint-disable-next-line import/no-deprecated
@@ -49,7 +46,10 @@ export interface ISerializableBlobContents {
  * container attach state.
  */
 export class ContainerStorageAdapter
-	implements ISerializedStateManagerDocumentStorageService, IDocumentStorageService, IDisposable
+	implements
+		ISerializedStateManagerDocumentStorageService,
+		IDocumentStorageService,
+		IDisposable
 {
 	private _storageService: IDocumentStorageService & Partial<IDisposable>;
 
@@ -77,7 +77,7 @@ export class ContainerStorageAdapter
 	 * @param loadingGroupIdSnapshotsFromPendingState - in offline mode, any loading group snapshots we've downloaded from the service that were stored in the pending state
 	 * @param addProtocolSummaryIfMissing - a callback to permit the container to inspect the summary we're about to
 	 * upload, and fix it up with a protocol tree if needed
-	 * @param forceEnableSummarizeProtocolTree - Enforce uploading a protocol summary regardless of the service's policy
+	 * @param enableSummarizeProtocolTree  - Enable uploading a protocol summary. Note: preference is given to service policy's "summarizeProtocolTree" before this value.
 	 */
 	public constructor(
 		// eslint-disable-next-line import/no-deprecated
@@ -89,10 +89,9 @@ export class ContainerStorageAdapter
 		private readonly blobContents: { [id: string]: ArrayBufferLike | string } = {},
 		private loadingGroupIdSnapshotsFromPendingState: Record<string, ISnapshotInfo> | undefined,
 		private readonly addProtocolSummaryIfMissing: (summaryTree: ISummaryTree) => ISummaryTree,
-		forceEnableSummarizeProtocolTree: boolean | undefined,
+		private readonly enableSummarizeProtocolTree: boolean | undefined,
 	) {
 		this._storageService = new BlobOnlyStorage(detachedBlobStorage, logger);
-		this._summarizeProtocolTree = forceEnableSummarizeProtocolTree;
 	}
 
 	disposed: boolean = false;
@@ -112,15 +111,33 @@ export class ContainerStorageAdapter
 			this.logger,
 		));
 
-		this._summarizeProtocolTree =
-			this._summarizeProtocolTree ?? service.policies?.summarizeProtocolTree;
-		if (this.summarizeProtocolTree) {
-			this.logger.sendTelemetryEvent({ eventName: "summarizeProtocolTreeEnabled" });
-			this._storageService = new ProtocolTreeStorageService(
-				retriableStorage,
-				this.addProtocolSummaryIfMissing,
-			);
-		}
+		// A storage service wrapper which intercept calls to uploadSummaryWithContext and ensure they include
+		// the protocol summary, provided single-commit summary is enabled.
+		this._storageService = new ProtocolTreeStorageService(
+			retriableStorage,
+			(...props) => {
+				this.logger.sendTelemetryEvent({ eventName: "summarizeProtocolTreeEnabled" });
+				return this.addProtocolSummaryIfMissing(...props);
+			},
+			// A callback to ensure we fetch the most updated value of service.policies.summarizeProtocolTree, which could be set
+			// based on the response received from the service after connection is established.
+			() => {
+				// Determine whether or not container should upload the protocol summary along with the summary.
+				// This is determined based on what value is set for serve policy's summariProtocolTree value or the enableSummarizeProtocolTree
+				// retrievd from the loader options or monitoring context config.
+				const shouldSummarizeProtocolTree =
+					service.policies?.summarizeProtocolTree ?? this.enableSummarizeProtocolTree ?? false;
+
+				if (this._summarizeProtocolTree !== shouldSummarizeProtocolTree) {
+					this.logger.sendTelemetryEvent({
+						eventName: "isSummarizeProtocolTreeEnabled",
+						details: { value: shouldSummarizeProtocolTree },
+					});
+				}
+				this._summarizeProtocolTree = shouldSummarizeProtocolTree;
+				return this._summarizeProtocolTree;
+			},
+		);
 	}
 
 	public loadSnapshotFromSnapshotBlobs(snapshotBlobs: ISerializableBlobContents) {
@@ -156,9 +173,7 @@ export class ContainerStorageAdapter
 			snapshotFetchOptions?.loadingGroupIds !== undefined
 		) {
 			const localSnapshot =
-				this.loadingGroupIdSnapshotsFromPendingState[
-					snapshotFetchOptions.loadingGroupIds[0]
-				];
+				this.loadingGroupIdSnapshotsFromPendingState[snapshotFetchOptions.loadingGroupIds[0]];
 			assert(localSnapshot !== undefined, 0x970 /* Local snapshot must be present */);
 			const attributes = await getDocumentAttributes(this, localSnapshot.baseSnapshot);
 			snapshot = convertSnapshotInfoToSnapshot(localSnapshot, attributes.sequenceNumber);

package/src/contracts.ts

@@ -12,16 +12,15 @@ import {
 	IConnectionDetails,
 } from "@fluidframework/container-definitions/internal";
 import { IErrorBase, ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
-import { IContainerPackageInfo } from "@fluidframework/driver-definitions/internal";
+import { ConnectionMode, IClientDetails } from "@fluidframework/driver-definitions";
 import {
-	ConnectionMode,
+	IContainerPackageInfo,
 	IClientConfiguration,
-	IClientDetails,
 	IDocumentMessage,
-	ISequencedDocumentMessage,
 	ISignalClient,
+	ISequencedDocumentMessage,
 	ISignalMessage,
-} from "@fluidframework/protocol-definitions";
+} from "@fluidframework/driver-definitions/internal";
 
 export enum ReconnectMode {
 	Never = "Never",

package/src/debugLogger.ts

@@ -16,13 +16,12 @@ import {
 	eventNamespaceSeparator,
 	formatTick,
 } from "@fluidframework/telemetry-utils/internal";
-
 // This import style is necessary to ensure the emitted JS code works in both CJS and ESM.
 import debugPkg from "debug";
-const { debug: registerDebug } = debugPkg;
-
 import type { IDebugger } from "debug";
 
+const { debug: registerDebug } = debugPkg;
+
 /**
  * Implementation of debug logger
  */

package/src/deltaManager.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
+import { ICriticalContainerError } from "@fluidframework/container-definitions";
 import {
-	ICriticalContainerError,
 	IDeltaManager,
 	IDeltaManagerEvents,
 	IDeltaQueue,
@@ -16,23 +16,21 @@ import {
 } from "@fluidframework/core-interfaces";
 import { IThrottlingWarning } from "@fluidframework/core-interfaces/internal";
 import { assert } from "@fluidframework/core-utils/internal";
+import { ConnectionMode } from "@fluidframework/driver-definitions";
 import {
 	IDocumentDeltaStorageService,
 	IDocumentService,
 	DriverErrorTypes,
+	IDocumentMessage,
+	MessageType,
+	ISequencedDocumentMessage,
+	ISignalMessage,
 } from "@fluidframework/driver-definitions/internal";
 import {
 	MessageType2,
 	NonRetryableError,
 	isRuntimeMessage,
 } from "@fluidframework/driver-utils/internal";
-import {
-	ConnectionMode,
-	IDocumentMessage,
-	ISequencedDocumentMessage,
-	ISignalMessage,
-	MessageType,
-} from "@fluidframework/protocol-definitions";
 import {
 	type ITelemetryErrorEventExt,
 	type ITelemetryGenericEventExt,
@@ -70,7 +68,10 @@ export interface IConnectionArgs {
 export interface IDeltaManagerInternalEvents extends IDeltaManagerEvents {
 	(event: "throttled", listener: (error: IThrottlingWarning) => void);
 	(event: "closed" | "disposed", listener: (error?: ICriticalContainerError) => void);
-	(event: "connect", listener: (details: IConnectionDetailsInternal, opsBehind?: number) => void);
+	(
+		event: "connect",
+		listener: (details: IConnectionDetailsInternal, opsBehind?: number) => void,
+	);
 	(event: "establishingConnection", listener: (reason: IConnectionStateChangeReason) => void);
 	(
 		event: "cancelEstablishingConnection",
@@ -471,9 +472,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		// Inbound signal queue
 		this._inboundSignal = new DeltaQueue<ISignalMessage>((message) => {
 			if (this.handler === undefined) {
-				throw new Error(
-					"Attempted to process an inbound signal without a handler attached",
-				);
+				throw new Error("Attempted to process an inbound signal without a handler attached");
 			}
 			this.handler.processSignal({
 				clientId: message.clientId,
@@ -1039,8 +1038,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 			if (message.type === MessageType.NoOp) {
 				this.noOpCount--;
 			}
-			const clientSeqNumGap =
-				message.clientSequenceNumber - this.lastClientSequenceNumber - 1;
+			const clientSeqNumGap = message.clientSequenceNumber - this.lastClientSequenceNumber - 1;
 			this.noOpCount -= clientSeqNumGap;
 			if (this.noOpCount < 0) {
 				throw new Error(`gap in client sequence number: ${clientSeqNumGap}`);
@@ -1144,10 +1142,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 				// Knowing about this mechanism, we could ask for op we already observed to increase validation.
 				// This is especially useful when coming out of offline mode or loading from
 				// very old cached (by client / driver) snapshot.
-				assert(
-					n === this.lastQueuedSequenceNumber,
-					0x0f2 /* "previouslyProcessedMessage" */,
-				);
+				assert(n === this.lastQueuedSequenceNumber, 0x0f2 /* "previouslyProcessedMessage" */);
 				assert(from > 1, 0x0f3 /* "not positive" */);
 				from--;
 			}

package/src/deltaQueue.ts

@@ -4,7 +4,10 @@
  */
 
 import { TypedEventEmitter, performance } from "@fluid-internal/client-utils";
-import { IDeltaQueue, IDeltaQueueEvents } from "@fluidframework/container-definitions/internal";
+import {
+	IDeltaQueue,
+	IDeltaQueueEvents,
+} from "@fluidframework/container-definitions/internal";
 import { assert } from "@fluidframework/core-utils/internal";
 import Deque from "double-ended-queue";
 

package/src/error.ts

@@ -16,7 +16,10 @@ import {
 /**
  * Warning emitted when requests to storage are being throttled.
  */
-export class ThrottlingWarning extends LoggingError implements IThrottlingWarning, IFluidErrorBase {
+export class ThrottlingWarning
+	extends LoggingError
+	implements IThrottlingWarning, IFluidErrorBase
+{
 	/**
 	 * {@inheritDoc @fluidframework/telemetry-utils#IFluidErrorBase.errorType}
 	 */

package/src/index.ts

@@ -21,3 +21,10 @@ export {
 } from "./location-redirection-utilities/index.js";
 export { IProtocolHandler, ProtocolHandlerBuilder } from "./protocol.js";
 export { tryParseCompatibleResolvedUrl, IParsedUrl } from "./utils.js";
+export {
+	IBaseProtocolHandler,
+	IScribeProtocolState,
+	IQuorumSnapshot,
+	QuorumClientsSnapshot,
+	QuorumProposalsSnapshot,
+} from "./protocol/index.js";

package/src/loadPaused.ts

@@ -5,8 +5,8 @@
 
 import { ILoader, LoaderHeader } from "@fluidframework/container-definitions/internal";
 import { IRequest } from "@fluidframework/core-interfaces";
-import { GenericError } from "@fluidframework/telemetry-utils/internal";
 import type { IErrorBase } from "@fluidframework/core-interfaces";
+import { GenericError } from "@fluidframework/telemetry-utils/internal";
 
 /* eslint-disable jsdoc/check-indentation */