@fluidframework/container-loader 1.2.7 → 2.0.0-dev.1.3.0.96595

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);
@@ -410,7 +439,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 +447,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 +482,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 +503,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 +551,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
                 to, // exclusive
                 controller.signal,
                 cacheOnly,
-                this.fetchReason);
+                fetchReason);
 
             // eslint-disable-next-line no-constant-condition
             while (true) {
@@ -761,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
@@ -815,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
@@ -876,6 +908,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, 0x37f /* reentrancy? */);
+                const result = this.processDeltas();
+                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)
+                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, 0x381 /* 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";