@fluidframework/container-loader 1.2.2 → 2.0.0-internal.1.0.0.82159

package/src/container.ts

@@ -7,7 +7,7 @@
 import merge from "lodash/merge";
 import { v4 as uuid } from "uuid";
 import {
-    IDisposable, ITelemetryProperties,
+    IDisposable, ITelemetryLogger, ITelemetryProperties,
 } from "@fluidframework/common-definitions";
 import { assert, performance, unreachableCase } from "@fluidframework/common-utils";
 import {
@@ -53,10 +53,7 @@ import {
     isRuntimeMessage,
     isUnpackedRuntimeMessage,
 } from "@fluidframework/driver-utils";
-import {
-    IProtocolHandler,
-    ProtocolOpHandlerWithClientValidation,
-} from "@fluidframework/protocol-base";
+import { IQuorumSnapshot } from "@fluidframework/protocol-base";
 import {
     IClient,
     IClientConfiguration,
@@ -109,6 +106,11 @@ import { initQuorumValuesFromCodeDetails, getCodeDetailsFromQuorumValues, Quorum
 import { CollabWindowTracker } from "./collabWindowTracker";
 import { ConnectionManager } from "./connectionManager";
 import { ConnectionState } from "./connectionState";
+import {
+    IProtocolHandler,
+    ProtocolHandler,
+    ProtocolHandlerBuilder,
+} from "./protocol";
 
 const detachedContainerRefSeqNumber = 0;
 
@@ -179,6 +181,10 @@ export async function waitContainerToCatchUp(container: IContainer) {
         };
         container.on("closed", closedCallback);
 
+        // Depending on config, transition to "connected" state may include the guarantee
+        // that all known ops have been processed.  If so, we may introduce additional wait here.
+        // Waiting for "connected" state in either case gets us at least to our own Join op
+        // which is a reasonable approximation of "caught up"
         const waitForOps = () => {
             assert(container.connectionState === ConnectionState.CatchingUp
                 || container.connectionState === ConnectionState.Connected,
@@ -228,6 +234,24 @@ const getCodeProposal =
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     (quorum: IQuorumProposals) => quorum.get("code") ?? quorum.get("code2");
 
+/**
+ * Helper function to report to telemetry cases where operation takes longer than expected (1s)
+ * @param logger - logger to use
+ * @param eventName - event name
+ * @param action - functor to call and measure
+ */
+async function ReportIfTooLong(
+    logger: ITelemetryLogger,
+    eventName: string,
+    action: () => Promise<ITelemetryProperties>,
+) {
+    const event = PerformanceEvent.start(logger, { eventName });
+    const props = await action();
+    if (event.duration > 1000) {
+        event.end(props);
+    }
+}
+
 /**
  * State saved by a container at close time, to be used to load a new instance
  * of the container to the same state
@@ -252,6 +276,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         loader: Loader,
         loadOptions: IContainerLoadOptions,
         pendingLocalState?: IPendingContainerState,
+        protocolHandlerBuilder?: ProtocolHandlerBuilder,
     ): Promise<Container> {
         const container = new Container(
             loader,
@@ -260,7 +285,8 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 resolvedUrl: loadOptions.resolvedUrl,
                 canReconnect: loadOptions.canReconnect,
                 serializedContainerState: pendingLocalState,
-            });
+            },
+            protocolHandlerBuilder);
 
         return PerformanceEvent.timedExecAsync(
             container.mc.logger,
@@ -308,10 +334,12 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     public static async createDetached(
         loader: Loader,
         codeDetails: IFluidCodeDetails,
+        protocolHandlerBuilder?: ProtocolHandlerBuilder,
     ): Promise<Container> {
         const container = new Container(
             loader,
-            {});
+            {},
+            protocolHandlerBuilder);
 
         return PerformanceEvent.timedExecAsync(
             container.mc.logger,
@@ -330,10 +358,13 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     public static async rehydrateDetachedFromSnapshot(
         loader: Loader,
         snapshot: string,
+        protocolHandlerBuilder?: ProtocolHandlerBuilder,
     ): Promise<Container> {
         const container = new Container(
             loader,
-            {});
+            {},
+            protocolHandlerBuilder);
+
         return PerformanceEvent.timedExecAsync(
             container.mc.logger,
             { eventName: "RehydrateDetachedFromSnapshot" },
@@ -387,7 +418,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     private readonly clientDetailsOverride: IClientDetails | undefined;
     private readonly _deltaManager: DeltaManager<ConnectionManager>;
     private service: IDocumentService | undefined;
-    private readonly _audience: Audience;
+    private _initialClients: ISignalClient[] | undefined;
 
     private _context: ContainerContext | undefined;
     private get context() {
@@ -510,13 +541,13 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
      * Retrieves the audience associated with the document
      */
     public get audience(): IAudience {
-        return this._audience;
+        return this.protocolHandler.audience;
     }
 
     /**
      * Returns true if container is dirty.
      * Which means data loss if container is closed at that same moment
-     * Most likely that happens when there is no network connection to ordering service
+     * Most likely that happens when there is no network connection to Relay Service
      */
     public get isDirty() {
         return this._dirtyContainer;
@@ -531,6 +562,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     constructor(
         private readonly loader: Loader,
         config: IContainerConfig,
+        private readonly protocolHandlerBuilder?: ProtocolHandlerBuilder,
     ) {
         super((name, error) => {
             this.mc.logger.sendErrorEvent(
@@ -540,7 +572,6 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 },
                 error);
         });
-        this._audience = new Audience();
 
         this.clientDetailsOverride = config.clientDetailsOverride;
         this._resolvedUrl = config.resolvedUrl;
@@ -566,6 +597,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                     containerAttachState: () => this._attachState,
                     containerLifecycleState: () => this._lifecycleState,
                     containerConnectionState: () => ConnectionState[this.connectionState],
+                    serializedContainer: config.serializedContainerState !== undefined,
                 },
                 // we need to be judicious with our logging here to avoid generating too much data
                 // all data logged here should be broadly applicable, and not specific to a
@@ -578,6 +610,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                     containerLoadedFromVersionId: () => this.loadedFromVersion?.id,
                     containerLoadedFromVersionDate: () => this.loadedFromVersion?.date,
                     // message information to associate errors with the specific execution state
+                    // dmLastMsqSeqNumber: if present, same as dmLastProcessedSeqNumber
                     dmLastMsqSeqNumber: () => this.deltaManager?.lastMessage?.sequenceNumber,
                     dmLastMsqSeqTimestamp: () => this.deltaManager?.lastMessage?.timestamp,
                     dmLastMsqSeqClientId: () => this.deltaManager?.lastMessage?.clientId,
@@ -772,8 +805,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         assert(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid",
             0x0d2 /* "resolved url should be valid Fluid url" */);
         assert(!!this._protocolHandler, 0x2e3 /* "Must have a valid protocol handler instance" */);
-        assert(this._protocolHandler.attributes.term !== undefined,
-            0x30b /* Must have a valid protocol handler instance */);
+        assert(this._protocolHandler.attributes.term !== undefined, "Must have a valid protocol handler instance");
         const pendingState: IPendingContainerState = {
             pendingRuntimeState: this.context.getPendingLocalState(),
             url: this.resolvedUrl.url,
@@ -1159,12 +1191,17 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         // ...load in the existing quorum
         // Initialize the protocol handler
         this._protocolHandler = pendingLocalState === undefined
-            ? await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot)
-            : await this.initializeProtocolState(
+            ? await this.initializeProtocolStateFromSnapshot(
+                attributes,
+                this.storageService,
+                snapshot,
+            ) : await this.initializeProtocolState(
                 attributes,
-                pendingLocalState.protocol.members,
-                pendingLocalState.protocol.proposals,
-                pendingLocalState.protocol.values,
+                {
+                    members: pendingLocalState.protocol.members,
+                    proposals: pendingLocalState.protocol.proposals,
+                    values: pendingLocalState.protocol.values,
+                }, // pending IQuorumSnapshot
             );
 
         const codeDetails = this.getCodeDetailsFromQuorum();
@@ -1175,17 +1212,20 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             pendingLocalState?.pendingRuntimeState,
         );
 
-        // Internal context is fully loaded at this point
-        this.setLoaded();
-
         // 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) {
             if (opsBeforeReturnP !== undefined) {
                 this._deltaManager.inbound.resume();
 
-                await opsBeforeReturnP;
-                await this._deltaManager.inbound.waitTillProcessingDone();
+                await ReportIfTooLong(
+                    this.mc.logger,
+                    "WaitOps",
+                    async () => { await opsBeforeReturnP; return {}; });
+                await ReportIfTooLong(
+                    this.mc.logger,
+                    "WaitOpProcessing",
+                    async () => this._deltaManager.inbound.waitTillProcessingDone());
 
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this._deltaManager.inbound.pause();
@@ -1215,9 +1255,14 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             throw new Error("Container was closed while load()");
         }
 
+        // Internal context is fully loaded at this point
+        this.setLoaded();
+
         return {
             sequenceNumber: attributes.sequenceNumber,
             version: versionId,
+            dmLastProcessedSeqNumber: this._deltaManager.lastSequenceNumber,
+            dmLastKnownSeqNumber: this._deltaManager.lastKnownSeqNumber,
         };
     }
 
@@ -1234,9 +1279,11 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         const qValues = initQuorumValuesFromCodeDetails(source);
         this._protocolHandler = await this.initializeProtocolState(
             attributes,
-            [], // members
-            [], // proposals
-            qValues,
+            {
+                members: [],
+                proposals: [],
+                values: qValues,
+            }, // IQuorumSnapShot
         );
 
         // The load context - given we seeded the quorum - will be great
@@ -1270,9 +1317,12 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         this._protocolHandler =
             await this.initializeProtocolState(
                 attributes,
-                [], // members
-                [], // proposals
-                codeDetails !== undefined ? initQuorumValuesFromCodeDetails(codeDetails) : []);
+                {
+                    members: [],
+                    proposals: [],
+                    values: codeDetails !== undefined ? initQuorumValuesFromCodeDetails(codeDetails) : [],
+                }, // IQuorumSnapShot
+            );
 
         await this.instantiateContextDetached(
             true, // existing
@@ -1336,44 +1386,40 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         storage: IDocumentStorageService,
         snapshot: ISnapshotTree | undefined,
     ): Promise<IProtocolHandler> {
-        let members: [string, ISequencedClient][] = [];
-        let proposals: [number, ISequencedProposal, string[]][] = [];
-        let values: [string, any][] = [];
+        const quorumSnapshot: IQuorumSnapshot = {
+            members: [],
+            proposals: [],
+            values: [],
+        };
 
         if (snapshot !== undefined) {
             const baseTree = getProtocolSnapshotTree(snapshot);
-            [members, proposals, values] = await Promise.all([
+            [quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] = await Promise.all([
                 readAndParse<[string, ISequencedClient][]>(storage, baseTree.blobs.quorumMembers),
                 readAndParse<[number, ISequencedProposal, string[]][]>(storage, baseTree.blobs.quorumProposals),
                 readAndParse<[string, ICommittedProposal][]>(storage, baseTree.blobs.quorumValues),
             ]);
         }
 
-        const protocolHandler = await this.initializeProtocolState(
-            attributes,
-            members,
-            proposals,
-            values);
-
+        const protocolHandler = await this.initializeProtocolState(attributes, quorumSnapshot);
         return protocolHandler;
     }
 
     private async initializeProtocolState(
         attributes: IDocumentAttributes,
-        members: [string, ISequencedClient][],
-        proposals: [number, ISequencedProposal, string[]][],
-        values: [string, any][],
+        quorumSnapshot: IQuorumSnapshot,
     ): Promise<IProtocolHandler> {
-        const protocol = new ProtocolOpHandlerWithClientValidation(
-            attributes.minimumSequenceNumber,
-            attributes.sequenceNumber,
-            attributes.term,
-            members,
-            proposals,
-            values,
+        const protocolHandlerBuilder =
+            this.protocolHandlerBuilder ?? ((...args) => new ProtocolHandler(...args, new Audience()));
+        const protocol = protocolHandlerBuilder(
+            attributes,
+            quorumSnapshot,
             (key, value) => this.submitMessage(MessageType.Propose, { key, value }),
+            this._initialClients ?? [],
         );
 
+        this._initialClients = undefined;
+
         const protocolLogger = ChildLogger.create(this.subLogger, "ProtocolHandler");
 
         protocol.quorum.on("error", (error) => {
@@ -1494,17 +1540,30 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inboundSignal.pause();
 
-        deltaManager.on("connect", (details: IConnectionDetails, opsBehind?: number) => {
-            // Back-compat for new client and old server.
-            this._audience.clear();
+        deltaManager.on("connect", (details: IConnectionDetails, _opsBehind?: number) => {
+            if (this._protocolHandler === undefined) {
+                // Store the initial clients so that they can be submitted to the
+                // protocol handler when it is created.
+                this._initialClients = details.initialClients;
+            } else {
+                // When reconnecting, the protocol handler is already created,
+                // so we can update the audience right now.
+                this._protocolHandler.audience.clear();
 
-            for (const priorClient of details.initialClients ?? []) {
-                this._audience.addMember(priorClient.clientId, priorClient.client);
+                for (const priorClient of details.initialClients ?? []) {
+                    this._protocolHandler.audience.addMember(priorClient.clientId, priorClient.client);
+                }
             }
 
+            const deltaManagerForCatchingUp =
+                this.mc.config.getBoolean("Fluid.Container.CatchUpBeforeDeclaringConnected") === true ?
+                    this.deltaManager
+                    : undefined;
+
             this.connectionStateHandler.receivedConnectEvent(
                 this.connectionMode,
                 details,
+                deltaManagerForCatchingUp,
             );
         });
 
@@ -1730,14 +1789,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     private processSignal(message: ISignalMessage) {
         // No clientId indicates a system signal message.
         if (message.clientId === null) {
-            const innerContent = message.content as { content: any; type: string; };
-            if (innerContent.type === MessageType.ClientJoin) {
-                const newClient = innerContent.content as ISignalClient;
-                this._audience.addMember(newClient.clientId, newClient.client);
-            } else if (innerContent.type === MessageType.ClientLeave) {
-                const leftClientId = innerContent.content as string;
-                this._audience.removeMember(leftClientId);
-            }
+            this.protocolHandler.processSignal(message);
         } else {
             const local = this.clientId === message.clientId;
             this.context.processSignal(message, local);

package/src/containerStorageAdapter.ts

@@ -6,6 +6,7 @@
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { ISnapshotTreeWithBlobContents } from "@fluidframework/container-definitions";
 import {
+    FetchSource,
     IDocumentStorageService,
     IDocumentStorageServicePolicies,
     ISummaryContext,
@@ -65,8 +66,13 @@ export class ContainerStorageAdapter implements IDocumentStorageService {
         return this.storageGetter().readBlob(id);
     }
 
-    public async getVersions(versionId: string | null, count: number, scenarioName?: string): Promise<IVersion[]> {
-        return this.storageGetter().getVersions(versionId, count, scenarioName);
+    public async getVersions(
+        versionId: string | null,
+        count: number,
+        scenarioName?: string,
+        fetchSource?: FetchSource,
+    ): Promise<IVersion[]> {
+        return this.storageGetter().getVersions(versionId, count, scenarioName, fetchSource);
     }
 
     public async uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string> {

package/src/deltaManager.ts

@@ -410,7 +410,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 
         if (prefetchType !== "none") {
             const cacheOnly = prefetchType === "cached";
-            await this.fetchMissingDeltasCore("DocumentOpen", cacheOnly, this.lastQueuedSequenceNumber);
+            await this.fetchMissingDeltasCore(`DocumentOpen_${prefetchType}`, cacheOnly);
 
             // Keep going with fetching ops from storage once we have all cached ops in.
             // But do not block load and make this request async / not blocking this api.
@@ -418,7 +418,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
             // (which in most cases will happen when we are done processing cached ops)
             if (cacheOnly) {
                 // fire and forget
-                this.fetchMissingDeltas("DocumentOpen");
+                this.fetchMissingDeltas("PostDocumentOpen");
             }
         }
 
@@ -453,6 +453,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
     private async getDeltas(
         from: number, // inclusive
         to: number | undefined, // exclusive
+        fetchReason: string,
         callback: (messages: ISequencedDocumentMessage[]) => void,
         cacheOnly: boolean) {
         const docService = this.serviceProvider();
@@ -473,7 +474,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
             // received through delta stream. Validate that before moving forward.
             if (this.lastQueuedSequenceNumber >= lastExpectedOp) {
                 this.logger.sendPerformanceEvent({
-                    reason: this.fetchReason,
+                    reason: fetchReason,
                     eventName: "ExtraStorageCall",
                     early: true,
                     from,
@@ -521,7 +522,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
                 to, // exclusive
                 controller.signal,
                 cacheOnly,
-                this.fetchReason);
+                fetchReason);
 
             // eslint-disable-next-line no-constant-condition
             while (true) {
@@ -876,6 +877,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
             await this.getDeltas(
                 from,
                 to,
+                fetchReason,
                 (messages) => {
                     this.refreshDelayInfo(this.deltaStorageDelayId);
                     this.enqueueMessages(messages, fetchReason);

package/src/deltaQueue.ts

@@ -4,7 +4,7 @@
  */
 
 import { IDeltaQueue, IDeltaQueueEvents } from "@fluidframework/container-definitions";
-import { assert, performance, Deferred, TypedEventEmitter } from "@fluidframework/common-utils";
+import { assert, performance, TypedEventEmitter } from "@fluidframework/common-utils";
 import Deque from "double-ended-queue";
 
 export interface IDeltaQueueWriter<T> {
@@ -30,7 +30,7 @@ export class DeltaQueue<T>
      * When processing is ongoing, holds a deferred that will resolve once processing stops.
      * Undefined when not processing.
      */
-    private processingDeferred: Deferred<void> | undefined;
+    private processingPromise: Promise<{ count: number; duration: number; }> | undefined;
 
     public get disposed(): boolean {
         return this.isDisposed;
@@ -48,13 +48,11 @@ export class DeltaQueue<T>
     }
 
     public get idle(): boolean {
-        return this.processingDeferred === undefined && this.q.length === 0;
+        return this.processingPromise === undefined && this.q.length === 0;
     }
 
-    public async waitTillProcessingDone(): Promise<void> {
-        if (this.processingDeferred !== undefined) {
-            return this.processingDeferred.promise;
-        }
+    public async waitTillProcessingDone() {
+        return this.processingPromise ?? { count: 0, duration: 0 };
     }
 
     /**
@@ -98,7 +96,7 @@ export class DeltaQueue<T>
         this.pauseCount++;
         // If called from within the processing loop, we are in the middle of processing an op. Return a promise
         // that will resolve when processing has actually stopped.
-        return this.waitTillProcessingDone();
+        await this.waitTillProcessingDone();
     }
 
     public resume(): void {
@@ -113,20 +111,31 @@ export class DeltaQueue<T>
      * not already started.
      */
     private ensureProcessing() {
-        if (!this.paused && this.processingDeferred === undefined) {
-            this.processingDeferred = new Deferred<void>();
+        if (this.anythingToProcess() && this.processingPromise === undefined) {
             // Use a resolved promise to start the processing on a separate stack.
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            Promise.resolve().then(() => {
-                this.processDeltas();
-                if (this.processingDeferred !== undefined) {
-                    this.processingDeferred.resolve();
-                    this.processingDeferred = undefined;
-                }
+            this.processingPromise = Promise.resolve().then(() => {
+                assert(this.processingPromise !== undefined, "reentrancy?");
+                const result = this.processDeltas();
+                assert(this.processingPromise !== undefined, "reentrancy?");
+                // WARNING: Do not move next line to .finally() clause!
+                // It runs async and creates a race condition where incoming ensureProcessing() call observes
+                // from previous run while previous run is over (but finally clause was not scheduled yet)
+                this.processingPromise = undefined;
+                return result;
+            }).catch((error) => {
+                this.error = error;
+                this.processingPromise = undefined;
+                this.emit("error", error);
+                return { count: 0, duration: 0 };
             });
+            assert(this.processingPromise !== undefined, "processDeltas() should run async");
         }
     }
 
+    private anythingToProcess() {
+        return this.q.length !== 0 && !this.paused && this.error === undefined;
+    }
+
     /**
      * Executes the delta processing loop until a stop condition is reached.
      */
@@ -136,24 +145,21 @@ export class DeltaQueue<T>
 
         // For grouping to work we must process all local messages immediately and in the single turn.
         // So loop over them until no messages to process, we have become paused, or hit an error.
-        while (!(this.q.length === 0 || this.paused || this.error !== undefined)) {
+        while (this.anythingToProcess()) {
             // Get the next message in the queue
             const next = this.q.shift();
             count++;
             // Process the message.
-            try {
-                // We know next is defined since we did a length check just prior to shifting.
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                this.worker(next!);
-                this.emit("op", next);
-            } catch (error) {
-                this.error = error;
-                this.emit("error", error);
-            }
+            // We know next is defined since we did a length check just prior to shifting.
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.worker(next!);
+            this.emit("op", next);
         }
 
+        const duration = performance.now() - start;
         if (this.q.length === 0) {
-            this.emit("idle", count, performance.now() - start);
+            this.emit("idle", count, duration);
         }
+        return { count, duration };
     }
 }

package/src/index.ts

@@ -21,3 +21,7 @@ export {
     Loader,
     RelativeLoader,
 } from "./loader";
+export {
+    IProtocolHandler,
+    ProtocolHandlerBuilder,
+} from "./protocol";

package/src/loader.ts

@@ -48,6 +48,7 @@ import {
 import { Container, IPendingContainerState } from "./container";
 import { IParsedUrl, parseUrl } from "./utils";
 import { pkgVersion } from "./packageVersion";
+import { ProtocolHandlerBuilder } from "./protocol";
 
 function canUseCache(request: IRequest): boolean {
     if (request.headers === undefined) {
@@ -211,7 +212,13 @@ export interface ILoaderProps {
     /**
      * The configuration provider which may be used to control features.
      */
-     readonly configProvider?: IConfigProviderBase;
+    readonly configProvider?: IConfigProviderBase;
+
+    /**
+    * Optional property for allowing the container to use a custom
+    * protocol implementation for handling the quorum and/or the audience.
+    */
+    readonly protocolHandlerBuilder?: ProtocolHandlerBuilder;
 }
 
 /**
@@ -278,6 +285,7 @@ export class Loader implements IHostLoader {
     private readonly containers = new Map<string, Promise<Container>>();
     public readonly services: ILoaderServices;
     private readonly mc: MonitoringContext;
+    private readonly protocolHandlerBuilder: ProtocolHandlerBuilder | undefined;
 
     constructor(loaderProps: ILoaderProps) {
         const scope: FluidObject<ILoader> = { ...loaderProps.scope };
@@ -306,6 +314,7 @@ export class Loader implements IHostLoader {
         };
         this.mc = loggerToMonitoringContext(
             ChildLogger.create(this.services.subLogger, "Loader"));
+        this.protocolHandlerBuilder = loaderProps.protocolHandlerBuilder;
     }
 
     public get IFluidRouter(): IFluidRouter { return this; }
@@ -314,6 +323,7 @@ export class Loader implements IHostLoader {
         const container = await Container.createDetached(
             this,
             codeDetails,
+            this.protocolHandlerBuilder,
         );
 
         if (this.cachingEnabled) {
@@ -330,7 +340,7 @@ export class Loader implements IHostLoader {
     }
 
     public async rehydrateDetachedContainerFromSnapshot(snapshot: string): Promise<IContainer> {
-        return Container.rehydrateDetachedFromSnapshot(this, snapshot);
+        return Container.rehydrateDetachedFromSnapshot(this, snapshot, this.protocolHandlerBuilder);
     }
 
     public async resolve(request: IRequest, pendingLocalState?: string): Promise<IContainer> {
@@ -482,6 +492,7 @@ export class Loader implements IHostLoader {
                 loadMode: request.headers?.[LoaderHeader.loadMode],
             },
             pendingLocalState,
+            this.protocolHandlerBuilder,
         );
     }
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "1.2.2";
+export const pkgVersion = "2.0.0-internal.1.0.0.82159";