@fluidframework/container-loader 1.3.0 → 2.0.0-dev.1.4.5.105745

package/src/containerContext.ts

@@ -4,7 +4,7 @@
  */
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { assert, LazyPromise } from "@fluidframework/common-utils";
+import { LazyPromise } from "@fluidframework/common-utils";
 import {
     IAudience,
     IContainerContext,
@@ -22,6 +22,7 @@ import {
     ICodeDetailsLoader,
     IFluidModuleWithDetails,
     ISnapshotTreeWithBlobContents,
+    IBatchMessage,
 } from "@fluidframework/container-definitions";
 import {
     IRequest,
@@ -42,6 +43,7 @@ import {
     ISummaryTree,
     IVersion,
     MessageType,
+    ISummaryContent,
 } from "@fluidframework/protocol-definitions";
 import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { Container } from "./container";
@@ -59,6 +61,8 @@ export class ContainerContext implements IContainerContext {
         quorum: IQuorum,
         loader: ILoader,
         submitFn: (type: MessageType, contents: any, batch: boolean, appData: any) => number,
+        submitSummaryFn: (summaryOp: ISummaryContent) => number,
+        submitBatchFn: (batch: IBatchMessage[]) => number,
         submitSignalFn: (contents: any) => void,
         closeFn: (error?: ICriticalContainerError) => void,
         version: string,
@@ -76,6 +80,8 @@ export class ContainerContext implements IContainerContext {
             quorum,
             loader,
             submitFn,
+            submitSummaryFn,
+            submitBatchFn,
             submitSignalFn,
             closeFn,
             version,
@@ -107,8 +113,13 @@ export class ContainerContext implements IContainerContext {
         return this.container.clientDetails;
     }
 
+    private _connected: boolean;
+    /**
+     * When true, ops are free to flow
+     * When false, ops should be kept as pending or rejected
+     */
     public get connected(): boolean {
-        return this.container.connected;
+        return this._connected;
     }
 
     public get canSummarize(): boolean {
@@ -166,6 +177,9 @@ export class ContainerContext implements IContainerContext {
         quorum: IQuorum,
         public readonly loader: ILoader,
         public readonly submitFn: (type: MessageType, contents: any, batch: boolean, appData: any) => number,
+        public readonly submitSummaryFn: (summaryOp: ISummaryContent) => number,
+        /** @returns clientSequenceNumber of last message in a batch */
+        public readonly submitBatchFn: (batch: IBatchMessage[]) => number,
         public readonly submitSignalFn: (contents: any) => void,
         public readonly closeFn: (error?: ICriticalContainerError) => void,
         public readonly version: string,
@@ -174,6 +188,7 @@ export class ContainerContext implements IContainerContext {
         public readonly pendingLocalState?: unknown,
 
     ) {
+        this._connected = this.container.connected;
         this._quorum = quorum;
         this.taggedLogger = container.subLogger;
         this._fluidModuleP = new LazyPromise<IFluidModuleWithDetails>(
@@ -183,9 +198,10 @@ export class ContainerContext implements IContainerContext {
     }
 
     /**
-     * @deprecated - Temporary migratory API, to be removed when customers no longer need it.  When removed,
-     * ContainerContext should only take an IQuorumClients rather than an IQuorum.  See IContainerContext for more
-     * details.
+     * @deprecated Temporary migratory API, to be removed when customers no longer need it.
+     * When removed, `ContainerContext` should only take an {@link @fluidframework/container-definitions#IQuorumClients}
+     * rather than an {@link @fluidframework/protocol-definitions#IQuorum}.
+     * See {@link @fluidframework/container-definitions#IContainerContext} for more details.
      */
     public getSpecifiedCodeDetails(): IFluidCodeDetails | undefined {
         return (this._quorum.get("code") ?? this._quorum.get("code2")) as IFluidCodeDetails | undefined;
@@ -223,9 +239,7 @@ export class ContainerContext implements IContainerContext {
 
     public setConnectionState(connected: boolean, clientId?: string) {
         const runtime = this.runtime;
-
-        assert(connected === this.connected, 0x0de /* "Mismatch in connection state while setting" */);
-
+        this._connected = connected;
         runtime.setConnectionState(connected, clientId);
     }
 

package/src/containerStorageAdapter.ts

@@ -3,13 +3,17 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { IDisposable, ITelemetryLogger } from "@fluidframework/common-definitions";
+import { assert } from "@fluidframework/common-utils";
 import { ISnapshotTreeWithBlobContents } from "@fluidframework/container-definitions";
 import {
+    FetchSource,
+    IDocumentService,
     IDocumentStorageService,
     IDocumentStorageServicePolicies,
     ISummaryContext,
 } from "@fluidframework/driver-definitions";
+import { UsageError } from "@fluidframework/driver-utils";
 import {
     ICreateBlobResponse,
     ISnapshotTree,
@@ -18,14 +22,52 @@ import {
     IVersion,
 } from "@fluidframework/protocol-definitions";
 import { IDetachedBlobStorage } from "./loader";
+import { ProtocolTreeStorageService } from "./protocolTreeDocumentStorageService";
+import { RetriableDocumentStorageService } from "./retriableDocumentStorageService";
 
 /**
  * This class wraps the actual storage and make sure no wrong apis are called according to
  * container attach state.
  */
-export class ContainerStorageAdapter implements IDocumentStorageService {
+export class ContainerStorageAdapter implements IDocumentStorageService, IDisposable {
     private readonly blobContents: { [id: string]: ArrayBufferLike; } = {};
-    constructor(private readonly storageGetter: () => IDocumentStorageService) {}
+    private _storageService: IDocumentStorageService & Partial<IDisposable>;
+
+    constructor(
+        detachedBlobStorage: IDetachedBlobStorage | undefined,
+        private readonly logger: ITelemetryLogger,
+        private readonly captureProtocolSummary?: () => ISummaryTree,
+    ) {
+        this._storageService = new BlobOnlyStorage(detachedBlobStorage, logger);
+    }
+
+    disposed: boolean = false;
+    dispose(error?: Error): void {
+        this._storageService?.dispose?.(error);
+        this.disposed = true;
+    }
+
+    public async connectToService(service: IDocumentService): Promise<void> {
+        if (!(this._storageService instanceof BlobOnlyStorage)) {
+            return;
+        }
+
+        const storageService = await service.connectToStorage();
+        const retriableStorage = this._storageService =
+            new RetriableDocumentStorageService(
+                storageService,
+                this.logger);
+
+        if (this.captureProtocolSummary !== undefined) {
+            this.logger.sendTelemetryEvent({ eventName: "summarizeProtocolTreeEnabled" });
+            this._storageService =
+                new ProtocolTreeStorageService(retriableStorage, this.captureProtocolSummary);
+        }
+
+        // ensure we did not lose that policy in the process of wrapping
+        assert(storageService.policies?.minBlobSize === this._storageService.policies?.minBlobSize,
+            0x0e0 /* "lost minBlobSize policy" */);
+    }
 
     public loadSnapshotForRehydratingContainer(snapshotTree: ISnapshotTreeWithBlobContents) {
         this.getBlobContents(snapshotTree);
@@ -44,17 +86,17 @@ export class ContainerStorageAdapter implements IDocumentStorageService {
         // back-compat 0.40 containerRuntime requests policies even in detached container if storage is present
         // and storage is always present in >=0.41.
         try {
-            return this.storageGetter().policies;
+            return this._storageService.policies;
         } catch (e) {}
         return undefined;
     }
 
     public get repositoryUrl(): string {
-        return this.storageGetter().repositoryUrl;
+        return this._storageService.repositoryUrl;
     }
 
     public async getSnapshotTree(version?: IVersion, scenarioName?: string): Promise<ISnapshotTree | null> {
-        return this.storageGetter().getSnapshotTree(version, scenarioName);
+        return this._storageService.getSnapshotTree(version, scenarioName);
     }
 
     public async readBlob(id: string): Promise<ArrayBufferLike> {
@@ -62,23 +104,28 @@ export class ContainerStorageAdapter implements IDocumentStorageService {
         if (blob !== undefined) {
             return blob;
         }
-        return this.storageGetter().readBlob(id);
+        return this._storageService.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._storageService.getVersions(versionId, count, scenarioName, fetchSource);
     }
 
     public async uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string> {
-        return this.storageGetter().uploadSummaryWithContext(summary, context);
+        return this._storageService.uploadSummaryWithContext(summary, context);
     }
 
     public async downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree> {
-        return this.storageGetter().downloadSummary(handle);
+        return this._storageService.downloadSummary(handle);
     }
 
     public async createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse> {
-        return this.storageGetter().createBlob(file);
+        return this._storageService.createBlob(file);
     }
 }
 
@@ -86,18 +133,25 @@ export class ContainerStorageAdapter implements IDocumentStorageService {
  * Storage which only supports createBlob() and readBlob(). This is used with IDetachedBlobStorage to support
  * blobs in detached containers.
  */
-export class BlobOnlyStorage implements IDocumentStorageService {
+class BlobOnlyStorage implements IDocumentStorageService {
     constructor(
-        private readonly blobStorage: IDetachedBlobStorage,
+        private readonly detachedStorage: IDetachedBlobStorage | undefined,
         private readonly logger: ITelemetryLogger,
     ) { }
 
     public async createBlob(content: ArrayBufferLike): Promise<ICreateBlobResponse> {
-        return this.blobStorage.createBlob(content);
+        return this.verifyStorage().createBlob(content);
     }
 
     public async readBlob(blobId: string): Promise<ArrayBufferLike> {
-        return this.blobStorage.readBlob(blobId);
+        return this.verifyStorage().readBlob(blobId);
+    }
+
+    private verifyStorage(): IDetachedBlobStorage {
+        if (this.detachedStorage === undefined) {
+            throw new UsageError("Real storage calls not allowed in Unattached container");
+        }
+        return this.detachedStorage;
     }
 
     public get policies(): IDocumentStorageServicePolicies | undefined {
@@ -117,6 +171,7 @@ export class BlobOnlyStorage implements IDocumentStorageService {
     /* eslint-enable @typescript-eslint/unbound-method */
 
     private notCalled(): never {
+        this.verifyStorage();
         try {
             // some browsers may not populate stack unless exception is thrown
             throw new Error("BlobOnlyStorage not implemented method used");

package/src/contracts.ts

@@ -56,13 +56,13 @@ export interface IConnectionManager {
 
     readonly readOnlyInfo: ReadOnlyInfo;
 
-    // Various connectivity propetries for telemetry describing type of current connection
+    // 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;
 
     // Verbose information about connection logged to telemetry in case of issues with
-    // maintaining healphy connection, including op gaps, not receiving join op in time, etc.
+    // 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;
 
@@ -73,7 +73,7 @@ export interface IConnectionManager {
     prepareMessageToSend(message: Omit<IDocumentMessage, "clientSequenceNumber">): IDocumentMessage | undefined;
 
     /**
-     * Called before incomming message is processed. Incomming messages can be comming from connection,
+     * Called before incoming message is processed. Incoming messages can be combing from connection,
      * but also could come from storage.
      * This call allows connection manager to adjust knowledge about acked ops sent on previous connection.
      * Can be called at any time, including when there is no active connection.
@@ -107,11 +107,11 @@ export interface IConnectionManager {
 
 /**
  * This interface represents a set of callbacks provided by DeltaManager to IConnectionManager on its creation
- * IConnectionManager instance will use them to communicate to DeltaManager abour various events.
+ * IConnectionManager instance will use them to communicate to DeltaManager about various events.
  */
 export interface IConnectionManagerFactoryArgs {
     /**
-     * Called by connection manager for each incomming op. Some ops maybe delivered before
+     * Called by connection manager for each incoming op. Some ops maybe delivered before
      * connectHandler is called (initial ops on socket connection)
      */
     readonly incomingOpHandler: (messages: ISequencedDocumentMessage[], reason: string) => void;
@@ -131,8 +131,8 @@ export interface IConnectionManagerFactoryArgs {
     readonly reconnectionDelayHandler: (delayMs: number, error: unknown) => void;
 
     /**
-     * Called by connection manager whwnever critical error happens and container should be closed.
-     * Expects dispose() call in respose to this call.
+     * Called by connection manager whenever critical error happens and container should be closed.
+     * Expects dispose() call in response to this call.
      */
     readonly closeHandler: (error?: any) => void;
 

package/src/deltaManager.ts

@@ -25,6 +25,8 @@ import {
     normalizeError,
     logIfFalse,
     safeRaiseEvent,
+    MonitoringContext,
+    loggerToMonitoringContext,
 } from "@fluidframework/telemetry-utils";
 import {
     IDocumentDeltaStorageService,
@@ -47,6 +49,7 @@ import {
     DataCorruptionError,
     extractSafePropertiesFromMessage,
     DataProcessingError,
+    UsageError,
 } from "@fluidframework/container-utils";
 import { DeltaQueue } from "./deltaQueue";
 import {
@@ -89,6 +92,15 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
     private pending: ISequencedDocumentMessage[] = [];
     private fetchReason: string | undefined;
 
+    private readonly mc: MonitoringContext;
+
+    // A boolean used to assert that ops are not being sent while processing another op.
+    private currentlyProcessingOps: boolean = false;
+
+    // Feature gate that closes a container when sending an op if the container is
+    // concurrently processing another op
+    private readonly preventConcurrentOpSend: boolean = true;
+
     // The minimum sequence number and last sequence number received from the server
     private minSequenceNumber: number = 0;
 
@@ -113,6 +125,8 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
     private previouslyProcessedMessage: ISequencedDocumentMessage | undefined;
 
     // The sequence number we initially loaded from
+    // In case of reading from a snapshot or pending state, its value will be equal to
+    // the last message that got serialized.
     private initSequenceNumber: number = 0;
 
     private readonly _inbound: DeltaQueue<ISequencedDocumentMessage>;
@@ -185,9 +199,12 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
     public get readOnlyInfo() { return this.connectionManager.readOnlyInfo; }
     public get clientDetails() { return this.connectionManager.clientDetails; }
 
-    public submit(type: MessageType, contents: any, batch = false, metadata?: any) {
+    public submit(type: MessageType, contents?: string, batch = false, metadata?: any) {
+        if (this.currentlyProcessingOps && this.preventConcurrentOpSend) {
+            this.close(new UsageError("Making changes to data model is disallowed while processing ops."));
+        }
         const messagePartial: Omit<IDocumentMessage, "clientSequenceNumber"> = {
-            contents: JSON.stringify(contents),
+            contents,
             metadata,
             referenceSequenceNumber: this.lastProcessedSequenceNumber,
             type,
@@ -196,13 +213,14 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
         if (!batch) {
             this.flush();
         }
-
         const message = this.connectionManager.prepareMessageToSend(messagePartial);
         if (message === undefined) {
             return -1;
         }
 
-        this.opsSize += message.contents.length;
+        if (contents !== undefined) {
+            this.opsSize += contents.length;
+        }
 
         this.messageBuffer.push(message);
 
@@ -211,22 +229,32 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
         if (!batch) {
             this.flush();
         }
-
         return message.clientSequenceNumber;
     }
 
     public submitSignal(content: any) { return this.connectionManager.submitSignal(content); }
 
     public flush() {
-        if (this.messageBuffer.length === 0) {
+        const batch = this.messageBuffer;
+        if (batch.length === 0) {
             return;
         }
 
+        this.messageBuffer = [];
+
         // The prepareFlush event allows listeners to append metadata to the batch prior to submission.
-        this.emit("prepareSend", this.messageBuffer);
+        this.emit("prepareSend", batch);
 
-        this.connectionManager.sendMessages(this.messageBuffer);
-        this.messageBuffer = [];
+        if (batch.length === 1) {
+            assert(batch[0].metadata?.batch === undefined, 0x3c9 /* no batch markup on single message */);
+        } else {
+            assert(batch[0].metadata?.batch === true, 0x3ca /* no start batch markup */);
+            assert(batch[batch.length - 1].metadata?.batch === false, 0x3cb /* no end batch markup */);
+        }
+
+        this.connectionManager.sendMessages(batch);
+
+        assert(this.messageBuffer.length === 0, 0x3cc /* reentrancy */);
     }
 
     public get connectionProps(): ITelemetryProperties {
@@ -293,7 +321,8 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
         };
 
         this.connectionManager = createConnectionManager(props);
-
+        this.mc = loggerToMonitoringContext(logger);
+        this.preventConcurrentOpSend = this.mc.config.getBoolean("Fluid.Container.ConcurrentOpSend") === true;
         this._inbound = new DeltaQueue<ISequencedDocumentMessage>(
             (op) => {
                 this.processInboundMessage(op);
@@ -762,6 +791,8 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 
     private processInboundMessage(message: ISequencedDocumentMessage): void {
         const startTime = Date.now();
+        assert(!this.currentlyProcessingOps, 0x3af /* Already processing ops. */);
+        this.currentlyProcessingOps = true;
         this.lastProcessedMessage = message;
 
         // All non-system messages are coming from some client, and should have clientId
@@ -816,7 +847,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
             throw new Error("Attempted to process an inbound message without a handler attached");
         }
         this.handler.process(message);
-
+        this.currentlyProcessingOps = false;
         const endTime = Date.now();
 
         // Should be last, after changing this.lastProcessedSequenceNumber above, as many callers

package/src/deltaQueue.ts

@@ -114,9 +114,9 @@ export class DeltaQueue<T>
         if (this.anythingToProcess() && this.processingPromise === undefined) {
             // Use a resolved promise to start the processing on a separate stack.
             this.processingPromise = Promise.resolve().then(() => {
-                assert(this.processingPromise !== undefined, "reentrancy?");
+                assert(this.processingPromise !== undefined, 0x37f /* reentrancy? */);
                 const result = this.processDeltas();
-                assert(this.processingPromise !== undefined, "reentrancy?");
+                assert(this.processingPromise !== undefined, 0x380 /* 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)
@@ -128,7 +128,7 @@ export class DeltaQueue<T>
                 this.emit("error", error);
                 return { count: 0, duration: 0 };
             });
-            assert(this.processingPromise !== undefined, "processDeltas() should run async");
+            assert(this.processingPromise !== undefined, 0x381 /* processDeltas() should run async */);
         }
     }
 

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) {
@@ -132,7 +133,7 @@ export interface ILoaderOptions extends ILoaderOptions1 {
 
 /**
  * @deprecated IFluidModuleWithDetails interface is moved to
- * {@link @fluidframework/container-definition#IFluidModuleWithDetails}
+ * {@link @fluidframework/container-definitions#IFluidModuleWithDetails}
  * to have all the code loading modules in one package. #8193
  * Encapsulates a module entry point with corresponding code details.
  */
@@ -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.3.0";
+export const pkgVersion = "2.0.0-dev.1.4.5.105745";

package/src/protocol.ts

@@ -0,0 +1,97 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IAudienceOwner } from "@fluidframework/container-definitions";
+import {
+    ILocalSequencedClient,
+    IProtocolHandler as IBaseProtocolHandler,
+    IQuorumSnapshot,
+    ProtocolOpHandler,
+} from "@fluidframework/protocol-base";
+import {
+    IDocumentAttributes,
+    IProcessMessageResult,
+    ISequencedDocumentMessage,
+    ISignalClient,
+    ISignalMessage,
+    MessageType,
+} from "@fluidframework/protocol-definitions";
+import { canBeCoalescedByService } from "@fluidframework/driver-utils";
+
+/**
+ * Function to be used for creating a protocol handler.
+ */
+export type ProtocolHandlerBuilder = (
+    attributes: IDocumentAttributes,
+    snapshot: IQuorumSnapshot,
+    sendProposal: (key: string, value: any) => number,
+    initialClients: ISignalClient[],
+) => IProtocolHandler;
+
+export interface IProtocolHandler extends IBaseProtocolHandler {
+    readonly audience: IAudienceOwner;
+    processSignal(message: ISignalMessage);
+}
+
+export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandler {
+    constructor(
+        attributes: IDocumentAttributes,
+        quorumSnapshot: IQuorumSnapshot,
+        sendProposal: (key: string, value: any) => number,
+        initialClients: ISignalClient[],
+        readonly audience: IAudienceOwner,
+    ) {
+        super(
+            attributes.minimumSequenceNumber,
+            attributes.sequenceNumber,
+            attributes.term,
+            quorumSnapshot.members,
+            quorumSnapshot.proposals,
+            quorumSnapshot.values,
+            sendProposal,
+        );
+
+        for (const initialClient of initialClients) {
+            this.audience.addMember(initialClient.clientId, initialClient.client);
+        }
+    }
+
+    public processMessage(message: ISequencedDocumentMessage, local: boolean): IProcessMessageResult {
+        const client: ILocalSequencedClient | undefined = this.quorum.getMember(message.clientId);
+
+        // Check and report if we're getting messages from a clientId that we previously
+        // flagged as shouldHaveLeft, or from a client that's not in the quorum but should be
+        if (message.clientId != null) {
+            if (client === undefined && message.type !== MessageType.ClientJoin) {
+                // pre-0.58 error message: messageClientIdMissingFromQuorum
+                throw new Error("Remote message's clientId is missing from the quorum");
+            }
+
+            if (client?.shouldHaveLeft === true && !canBeCoalescedByService(message)) {
+                // pre-0.58 error message: messageClientIdShouldHaveLeft
+                throw new Error("Remote message's clientId already should have left");
+            }
+        }
+
+        return super.processMessage(message, local);
+    }
+
+    public processSignal(message: ISignalMessage) {
+        const innerContent = message.content as { content: any; type: string; };
+        switch (innerContent.type) {
+            case MessageType.ClientJoin: {
+                const newClient = innerContent.content as ISignalClient;
+                this.audience.addMember(newClient.clientId, newClient.client);
+                break;
+            }
+            case MessageType.ClientLeave: {
+                const leftClientId = innerContent.content as string;
+                this.audience.removeMember(leftClientId);
+                break;
+            }
+            default: break;
+        }
+    }
+}